Language: C++

#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n)   REP(i,0,n)
#define pb         push_back

const int N = 27;

class st{
public:
  int x,y,z;
  bool operator<(const st &a)const{
    if (x != a.x)return x < a.x;
    if (y != a.y)return y<  a.y;
    return z < a.z;
  }
  bool operator==(const st &a)const{
    return x==a.x&&y==a.y&&z==a.z;
  }
};

bool isout(int x,int w){
  return x<0||w<=x;
}

void rotate(int &x,int &y){
  swap(x,y);
  x*=-1;
}

vector<st> move3(vector<st>in,int h,int d,int w){
  sort(in.begin(),in.end());
  vector<st> ret=in;
  rep(i,ret.size()){
    ret[i].x+=w;
    ret[i].y+=d;
    ret[i].z+=h;
  }
  return ret;
}

vector<st> move2(vector<st> &in){
  int difx=in[0].x,dify=in[0].y,difz=in[0].z;
  vector<st>ret=in;
  rep(i,in.size()){
    ret[i].x-=difx;
    ret[i].y-=dify;
    ret[i].z-=difz;
  }
  return ret;
}


bool issame(vector<st> a,vector<st> b){
  sort(a.begin(),a.end());
  sort(b.begin(),b.end());
  rep(i,a.size()){
    if (!(a[i] == b[i]))return false;
  }
  return true;
}

void generate(vector<vector<st> > &a,vector<st>in,int h,int d,int w){
  rep(x,4){
    rep(k,in.size())rotate(in[k].y,in[k].z);
    rep(y,4){
      rep(k,in.size())rotate(in[k].z,in[k].x);
      rep(z,4){
	rep(k,in.size())rotate(in[k].x,in[k].y);
	vector<st> ins=move3(in,h,d,w);
	ins=move2(ins);
	//rep(k,ins.size())if (isout(ins[k].x,w)||isout(ins[k].y,d)||isout(ins[k].z,h)){ins.clear();break;}
	if (ins.size())a.pb(ins);
      }
    }
  }

  sort(a.begin(),a.end());
  
  for(int i=(int)a.size()-1;i>=0;i--){
    for(int j=(int)a.size()-1;j>i;j--){
      if (issame(a[i],a[j])){
	a.erase(a.begin()+j);
      }
    }
  }
}

void generate2(vector<vector<st> > &a,vector<st>in,int h,int d,int w){
  rep(x,4){
    rep(k,in.size())rotate(in[k].y,in[k].z);
    rep(y,4){
      rep(k,in.size())rotate(in[k].z,in[k].x);
      rep(z,4){
	rep(k,in.size())rotate(in[k].x,in[k].y);
	vector<st> ins=move3(in,h,d,w);
	a.pb(ins);
      }
    }
  }

  sort(a.begin(),a.end());
  a.erase(unique(a.begin(),a.end()),a.end());
}


bool canins(bool box[3][3][3],vector<st> &in,int h,int d,int w){
  rep(i,in.size())
    if (box[in[i].z][in[i].y][in[i].x])return false;
  return true;
}

void insert(bool box[3][3][3],vector<st> &in,int h,int d,int w){
  rep(i,in.size())box[in[i].z][in[i].y][in[i].x]=!box[in[i].z][in[i].y][in[i].x];
}

vector<st> move(vector<st> &in,int y,int x,int z,
		int h,int d,int w){
  int difx=in[0].x-x,dify=in[0].y-y,difz=in[0].z-z;
  vector<st>ret=in;
  rep(i,in.size()){
    ret[i].x-=difx;
    ret[i].y-=dify;
    ret[i].z-=difz;
    if (isout(ret[i].x,w)||isout(ret[i].y,d)||isout(ret[i].z,h)){ret.clear();return ret;}
  }
  return ret;
}

int encode(bool box[3][3][3],int h,int d,int w){
  int ret=0;
  rep(i,h){
    rep(j,d){
      rep(k,w){
	ret=(ret<<1);
	if (box[i][j][k])ret++;
      }
    }
  }
  return ret;
}

bool dcheck(vector<vector<st> > &a,set<int> &S,int h,int d,int w){
  bool t[3][3][3];
  rep(i,a.size()){
    rep(j,3)rep(k,3)rep(l,3)t[j][k][l]=false;
    bool isok=true;
    rep(j,a[i].size()){
      if (isout(a[i][j].z,h)||isout(a[i][j].y,d)||isout(a[i][j].x,w)){
	isok=false;
	break;
      }
      t[a[i][j].z][a[i][j].y][a[i][j].x]=true;
    }
    if (isok && S.find(encode(t,h,d,w)) != S.end())return false;
    if (isok)S.insert(encode(t,h,d,w));
  }
  return true;
}

int dx[]={1,-1,0, 0,0, 0};
int dy[]={0, 0,1,-1,0, 0};
int dz[]={0,0,0,0,  1,-1};
void dfs(bool box[3][3][3],bool vis[3][3][3],int h,int d,int w,
	 int z,int y,int x,int &cn){
  if (vis[z][y][x])return;
  cn++;
  vis[z][y][x]=true;
  rep(i,6){
    int nex=x+dx[i],ney=y+dy[i],nez=z+dz[i];
    if (isout(nez,h)||isout(ney,d)||isout(nex,w)||box[nez][ney][nex])continue;
    dfs(box,vis,h,d,w,nez,ney,nex,cn);
  }
}

int pr(bool box[3][3][3],int h,int d,int w){
  bool vis[3][3][3]={false};
  int maxi=0;
  rep(i,h){
    rep(j,d){
      rep(k,w){
	if (!box[i][j][k]&&!vis[i][j][k]){
	  int cn=0;
	  dfs(box,vis,h,d,w,i,j,k,cn);
	  maxi=max(maxi,cn);
	}
      }
    }
  }
  return maxi;
}

int cnt = 0;
bool solve(int n,vector<vector<st> >*a,int now,int h,int d,int w,
	   bool box[3][3][3],set<int> *S){
  if (n == now)return true;
  int tmp=encode(box,h,d,w);

  //  cnt++;
  //  if (cnt&&cnt%1000==0)cout << cnt << endl;
  
  if (S[now].find(encode(box,h,d,w)) != S[now].end()){
    return false;
  }

//   vector<st> hoge;
//   rep(i,h){
//     rep(j,w){
//       rep(k,d)if (box[i][j][k])hoge.pb((st){j,k,i});
//     }
//   }
//   vector<vector<st> > cut;
//   generate2(cut,hoge,h,d,w);
  if (!dcheck(cut,S[now],h,d,w)){
    return false;
  }
  S[now].insert(tmp);
  
  int maxi = pr(box,h,d,w);
  REP(i,now,n){
    if (a[i][0].size() > maxi)return false;
  }
  //  if (a[now].size()&&
  //      !pr(box,h,d,w,a[now][0].size()))return false;

//   cout << "not cut " << endl;
//   rep(k,h){
//     cout << k << endl;
//     rep(i,d){
//       rep(j,w)cout << box[k][i][j];
//       cout << endl;
//     }
//     cout << endl;
//   }
  
  rep(i,a[now].size()){
    bool isok;
    int t;
    rep(y,d){
      isok=true;
      t=a[now][i][0].y-y;
      rep(k,a[now][i].size())
	if (a[now][i][k].y-t<0)isok=false;
      if (!isok)continue;
      rep(k,a[now][i].size()){
	if (a[now][i][k].y-t>=d)isok=false;
      }
      if (!isok)break;

      rep(x,w){
	isok=true;
	t=a[now][i][0].x-x;
	rep(k,a[now][i].size())
	  if (a[now][i][k].x-t<0)isok=false;
	if (!isok)continue;
	rep(k,a[now][i].size())
	  if (a[now][i][k].x-t>=w)isok=false;
	if (!isok)break;
	rep(z,h){
	  isok=true;
	  t=a[now][i][0].z-z;
	  rep(k,a[now][i].size())
	    if (a[now][i][k].z-t<0)isok=false;
	  if (!isok)continue;
	  rep(k,a[now][i].size())
	    if (a[now][i][k].z-t >= h)isok=false;
	  if (!isok)break;
	  vector<st> ins=move(a[now][i],y,x,z,h,d,w);
	  if (ins.size() && canins(box,ins,h,d,w)){
	    insert(box,ins,h,d,w);
	    if (solve(n,a,now+1,h,d,w,box,S))return true;
	    insert(box,ins,h,d,w);
	  }
	}
      }
    }
  }
  return false;
}

vector<st> getinput(){
  int h,d,w;
  cin>>w>>d>>h;
  vector<st> ret;
  rep(k,h){
    rep(i,d){
      rep(j,w){
	char tmp;
	cin>>tmp;
	if (tmp == '*')ret.pb((st){j,i,h});
      }
    }
  }
  return ret;
}

main(){
  int w,h,d,n;
  while(cin>>w>>d>>h>>n && n){
    //    cout << w <<" " << d <<" " << h <<" " << n << endl;
    cnt=0;
    bool box[3][3][3]={false};
    set<int> S[N];
    vector<vector<st> > a[N];
    vector<vector<st> > inp[N];
    int dec=0;
    rep(i,n){
      inp[i].pb(getinput());
      //      if (i==0)a[0].pb(getinput());
      //      else generate(a[i],getinput(),h,d,w);
      generate(a[i],inp[i][0],h,d,w);
    }


    int maxi=inp[0].size(),ind=0;
    rep(i,n){
      if (inp[i].size() > maxi)maxi=ind=i,maxi=inp[i].size();
    }
    a[ind]=inp[ind];

    for(int i=1;i<n;i++){
      for(int j=i+1;j<n;j++){
	if (a[i].size() > a[j].size())
	  swap(a[i],a[j]);
      }
    }

    int p=0;
    for(int i=0;i<n;i++)if (a[i][0].size()==1)p++;

//     rep(i,n){
//       cout <<i <<" " <<  a[i].size() << endl;
//       rep(j,a[i].size()){
// 	cout << "s"<<endl;
// 	rep(k,a[i][j].size()){
// 	  cout << a[i][j][k].x <<" " << a[i][j][k].y <<" " << a[i][j][k].z << endl;
// 	}
// 	cout <<"e"<<endl;
//       }
//     }
    if (solve(n,a,p,h,d,w,box,S))cout <<"Yes"<<endl;
    else cout << "No"<<endl;
  }
}

Compiler output:
a.cc: In function 'bool solve(int, std::vector<std::vector<st> >*, int, int, int, int, bool (*)[3][3], std::set<int>*)':
a.cc:217:15: error: 'cut' was not declared in this scope; did you mean 'cnt'?
  217 |   if (!dcheck(cut,S[now],h,d,w)){
      |               ^~~
      |               cnt
a.cc: At global scope:
a.cc:300:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
  300 | main(){
      | ^~~~