Problem:
B: テトリス
問題
縦 4 マス x 横 10 マスの長方形からなる盤面を考えます。
縦 1 マス x 横 1 マスぶんの正方形をブロックと呼びます。
ブロックを 4 つ繋げたものをテトロミノと呼び、以下の 7 種類（およびこれらに対して 90 度回転を任意回行ったもの）があります。
さて、盤面のうち 28 個のマスにブロックが置かれた状態を考えます。
左の図のように、各ブロック（赤色で表される）はマスに合うように置かれます。右の図のように半端な位置に置かれることはありません。
4 つのテトロミノ
t_1
,
t_2
,
t_3
,
t_4
が与えられるので、このうちちょうど 3 つを選んですきな位置に置くことで、盤面全体にブロックが置かれた状態にできるか判定してください。
ただし、テトロミノを配置するにあたり、以下の条件をすべて満たさなければなりません。
ブロック同士が重なってはいけない。
与えられたテトロミノを回転させてはいけない。
各
i
(
1 \leq i \leq 4
) について、テトロミノ
t_i
を 2 回以上使ってはいけない。
テトロミノの各ブロックは盤面の外に出てはいけない。
盤面が
n
個与えられるので、各盤面についてこの判定を行い、盤面全体にブロックを置けるならば
Yes
、不可能ならば
No
を出力してください。
入力形式
t_1
t_2
t_3
t_4
n
B_1
…
B_n
はじめに、使えるテトロミノ
t_1
,
t_2
,
t_3
,
t_4
が与えられます。
各
t_i
(
1 \leq i \leq 4
) は以下の形式で与えられます。
h
w
s_1
…
s_h
これはテトロミノを含む縦
h
x 横
w
マスの長方形であり、テトロミノの形状は
s_1 … s_h
で表されます。長方形のうち、テトロミノを表す部分は
#
、それ以外の部分は
.
で表されます。各長方形に
#
はちょうど 4 つ含まれます。
.
のみからなる行または列は存在しません。
次に、盤面の個数
n
が与えられます。
その後、
4\times 10
マスで表される盤面
B
が
n
個与えられます。
ブロックがある位置が
#
、ない位置が
.
で示されます。
制約
1\leq n\leq 10^5
与えられる各テトロミノは上で述べた条件に違反しない
各盤面について、
#
はちょうど 28 個存在する
たとえば、以下のようなテトロミノは与えられない。
3 3
..#
.#.
##.
（連結でないブロックがあり、これは上で述べたテトロミノの条件を満たさない）
3 3
...
.#.
###
（一番上の行が
.
のみからなる）
出力形式
n
行にわたって出力してください。
i
行目には盤面
B_i
に対する判定結果を
Yes
または
No
で出力してください。
入力例1
2 3
##.
.##
2 3
#..
###
1 4
####
2 3
###
.#.
2
####....##
####...###
####..####
####...###
###..#####
###...####
###...####
###....###
出力例1
Yes
Yes
t_1
,
t_2
,
t_3
,
t_4
に相当するテトロミノが置かれる場所をそれぞれ
1
,
2
,
3
,
4
で示すと、各盤面は次のように敷き詰められます。
####3333##
####444###
####24####
####222###
###11#####
###211####
###222####
###3333###
各盤面について、別々のテトロミノを選んで構いません。
入力例2
1 4
####
1 4
####
2 2
##
##
2 2
##
##
4
######....
....######
#######..#
#######..#
....######
######....
....######
##########
######.#.#
######.#.#
##..##.#.#
##..##.#.#
##.###.#.#
#.#.###.##
#.#.###.##
##.###.#.#
出力例2
Yes
No
No
No
####
が足りないため、2 つ目の盤面をブロックで敷き詰めることはできません。
また、テトロミノを回転させることはできないので、3 つ目の盤面を敷き詰めることもできません。
また、4 つ目の盤面のようなブロックの配置の仕方もありえることに注意してください。すなわち、入力で与えられる盤面はテトロミノを組み合わせて作られる盤面とは限りません。

Submitted solutions:

code_snippet: // AOJ #3108
// Perfect 2025.2.3

#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;

static inline ull cellBit(int row, int col) {
    return ull(1) << (row * 10 + col);
}

vector<pair<int,int>> readTetromino() {
    int h, w;
    cin >> h >> w;
    vector<pair<int,int>> cells;
    cells.reserve(4);
    for(int r=0; r<h; r++){
        string line;
        cin >> line;
        for(int c=0; c<w; c++){
            if(line[c] == '#'){
                // テトロミノに含まれるマス(相対座標)
                cells.push_back({r, c});
            }
        }
    }
    return cells;
}

vector<ull> buildAllPlacementsMask(const vector<pair<int,int>>& tet) {
    // テトロミノのbounding box 高さ, 幅を求める
    int maxr = 0, maxc = 0;
    for(auto &p : tet){
        maxr = max(maxr, p.first);
        maxc = max(maxc, p.second);
    }
    int h = maxr + 1;
    int w = maxc + 1;
    
    vector<ull> masks;
    for(int baseR = 0; baseR <= 4 - h; baseR++){
        for(int baseC = 0; baseC <= 10 - w; baseC++){
            // 4マスをビットマスクに落とし込む
            ull mask = 0ULL;
            for(auto &p : tet){
                int r = baseR + p.first;
                int c = baseC + p.second;
                mask |= cellBit(r, c);
            }
            masks.push_back(mask);
        }
    }
    return masks;
}

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);

    // 1. テトロミノ4つを読み込む
    vector<vector<pair<int,int>>> tet(4);
    for(int i=0; i<4; i++){
        tet[i] = readTetromino();
    }

    // 2. 各テトロミノを盤面に置いたときの全ビットマスクを前計算
    vector<vector<ull>> shapeMasks(4);
    for(int i=0; i<4; i++){
        shapeMasks[i] = buildAllPlacementsMask(tet[i]);
    }

    // 3. 「3つのテトロミノを重ならずに置いたときにちょうど埋まるマス集合」のビットマスクを全列挙し、セットに保存
    unordered_set<ull> validPatterns;
    validPatterns.reserve(200000);

    vector<int> idx = {0,1,2,3};
    for(int i=0;i<4;i++){
        for(int j=i+1;j<4;j++){
            for(int k=j+1;k<4;k++){
                for(ull m1 : shapeMasks[i]){
                    for(ull m2 : shapeMasks[j]){
                        if(m1 & m2) continue;
                        ull m12 = m1 | m2;
                        for(ull m3 : shapeMasks[k]){
                            if(m12 & m3) continue;
                            ull totalMask = m12 | m3;
                            validPatterns.insert(totalMask);
                        }
                    }
                }
            }
        }
    }

    // 4. 入力される盤面 n 個について判定
    int n;
    cin >> n;

    while(n--){
        ull emptyMask = 0ULL;
        for(int r=0; r<4; r++){
            string row;
            cin >> row;
            for(int c=0; c<10; c++){
                if(row[c] == '.') {
                    emptyMask |= cellBit(r, c);
                }
            }
        }
        if(validPatterns.find(emptyMask) != validPatterns.end()){
            cout << "Yes" << endl;
        } else {
            cout << "No" << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 5316
final_rank: 8

code_snippet: #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)

using namespace std;
using ll = long long;
using P = pair<int,int>;
const int mod=998244353;
const int inf = (1<<30);

const int dy[4] = {-1,0,0,1};
const int dx[4] = {0,-1,-1,0};


bool is_inside(int y,int x) {
    return 0 <= y and y < 4 and 0 <= x and x < 10;
}


pair<bool, vector<string>> put(const vector<string> &s, const vector<string> &mino, int sy,int sx) {
    rep(i, mino.size()) {
        rep(j, mino[i].size()) {
            int y = sy + i;
            int x = sx + j;

            if (not is_inside(y, x)) {
                return {false, {}};
            }

            if (mino[i][j] == '.'){
                continue;
            }

            if (s[y][x] == '#') {
                return {false, {}};
            }
        }
    }

    vector<string> res = s;

    rep(i, mino.size()) {
        rep(j, mino[i].size()) {
            int y = sy + i;
            int x = sx + j;

            if (mino[i][j] == '.'){
                continue;
            }

            res[y][x] = '#';
        }
    }
    return {true, res};
}


ll flip_and_to_ll(const vector<string> &s) {
    ll res = 0;

    rep(i, 4) {
        rep(j, 10) {
            int idx = i*10 + j;
            if (s[i][j] == '.') {
                res |= 1LL << idx;
            }
        }
    }

    return res;
}

ll to_ll(const vector<string> &s) {
    ll res = 0;

    rep(i, 4) {
        rep(j, 10) {
            int idx = i*10 + j;
            if (s[i][j] == '#') {
                res |= 1LL << idx;
            }
        }
    }

    return res;
}

void debug_output(vector<string> s) {
    cout << "debug begin here" << endl;
    rep(i, s.size()) {
        cout << s[i] << endl;
    }
    cout << "debug end here" << endl;
}

set<ll> ok;
vector<int> use;
vector<vector<string>> minos(4);

void dfs(int i, const vector<string> &s) {
    if (i == 4) {
        ok.insert(flip_and_to_ll(s));
        return;
    }

    if (not use[i]) {
        dfs(i+1, s);
        return;
    }

    rep(y, 4) {
        rep(x, 10) {
            auto [can, res] = put(s, minos[i], y, x);
            if (can) {
                dfs(i+1, res);
            }
        }
    }

    return;
}


int main() {
    cin.tie(0);
    ios::sync_with_stdio(0);

    vector<int> h(4), w(4);

    rep(i, 4) {
        cin >> h[i] >> w[i];

        minos[i] = vector<string>(h[i]);

        rep(j, h[i]) {
            cin >> minos[i][j];
        }
    }

    use = vector<int>(4, 0);
    use[0] = use[1] = use[2] = 1;
    sort(use.begin(), use.end());

    do {
        vector<string> s(4);
        rep(y, 4) {
            rep(x, 10) {
                s[y] += ".";
            }
        }

        dfs(0, s);
    } while(next_permutation(use.begin(), use.end()));

    int n;
    cin >> n;

    rep(_, n) {
        vector<string> b(4);
        rep(i, 4) {
            cin >> b[i];
        }

        ll b_val = to_ll(b);
        if (ok.find(b_val) != ok.end()) {
            cout << "Yes" << "\n";
        } else {
            cout << "No" << "\n";
        }
    }

}
accuracy: 1
time_ms: 30
memory_kb: 4428
final_rank: 5

code_snippet: #include<bits/stdc++.h>
using namespace std;

using State = array<string, 4>;

struct Mino {
    int h;
    int w;
    vector<string> block;
    Mino() = default;
    Mino(int h, int w, vector<string>& block) : h(h), w(w), block(block) {}
};

int main(){
    vector<Mino> minos(4);
    for (int i = 0; i < 4; i++) {
        int h, w;
        cin >> h >> w;
        vector<string> block(h);
        for (int j = 0; j < h; j++) cin >> block[j];
        minos[i] = Mino(h, w, block);
    }
    State black;
    for (int i = 0; i < 4; i++) black[i] = "##########";

    set<State> s;
    array<int, 3> index;

    auto dfs = [&](auto dfs, State& state, int i) -> void {
        if (i == 3) {
            s.emplace(state);
            return;
        }
        Mino& mino = minos[index[i]];
        for (int j = 0; j + mino.h <= 4; j++) {
            for (int k = 0; k + mino.w <= 10; k++) {
                bool flag = true;
                // check
                for (int dj = 0; dj < mino.h; dj++) {
                    for (int dk = 0; dk < mino.w; dk++) {
                        if (mino.block[dj][dk] == '#' && state[j + dj][k + dk] == '.') {
                            flag = false;
                            break;
                        }
                    }
                }
                if (!flag) continue;
                // add
                for (int dj = 0; dj < mino.h; dj++) {
                    for (int dk = 0; dk < mino.w; dk++) {
                        if (mino.block[dj][dk] == '#') {
                            assert(state[j + dj][k + dk] == '#');
                            state[j + dj][k + dk] = '.';
                        }
                    }
                }
                dfs(dfs, state, i + 1);
                // erase
                for (int dj = 0; dj < mino.h; dj++) {
                    for (int dk = 0; dk < mino.w; dk++) {
                        if (mino.block[dj][dk] == '#') {
                            assert(state[j + dj][k + dk] == '.');
                            state[j + dj][k + dk] = '#';
                        }
                    }
                }
            }
        }
    };

    for (int i = 0; i < 4; i++) {
        for (int j = i + 1; j < 4; j++) {
            for (int k = j + 1; k < 4; k++) {
                index[0] = i; index[1] = j; index[2] = k;
                dfs(dfs, black, 0);
            }
        }
    }

    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        State state;
        for (int j = 0; j < 4; j++) cin >> state[j];
        if (s.find(state) != s.end()) {
            cout << "Yes" << endl;
        } else {
            cout << "No" << endl;
        }
    }
}
accuracy: 1
time_ms: 150
memory_kb: 7000
final_rank: 12

code_snippet: #include<bits/stdc++.h>

using namespace std;

using P = pair<int,int>;

vector<P> input_area(int h,int w){
  vector<P> res;
  for(int i=0;i<h;++i){
    for(int j=0;j<w;++j){
      char c;
      cin >> c;
      if(c == '#'){
        res.emplace_back(i,j);
      }
    }
  }
  return res;
}

vector<P> input_mino(){
  int h;
  int w;
  cin >> h >> w;
  return input_area(h,w);
}

bool func(vector<vector<P>> &minos){
  vector<vector<char>> table(4,vector<char>(10));
  for(auto &i:table)for(auto &j:i)cin>>j;
  vector<P> poss;
  for(int i=0;i<4;++i){
    for(int j=0;j<10;++j){
      if(table[i][j]=='.'){
        poss.emplace_back(i,j);
      }
    }
  }
  auto rec = [&](auto rec, int tp,int used,int used_count) -> bool {
    //cout << tp << " " << used_count << " " << used << endl;
    //for(auto i:table){
    //  for(auto j:i)cout << j;
    //  cout << endl;
    //}
    //cout << endl;
    if(used_count == 3)return true;
    if(tp == poss.size())return false;
    if(table[poss[tp].first][poss[tp].second] == '#'){
      return rec(rec, tp+1,used,used_count);
    }
    for(int use = 0;use<4;++use){
      if((1<<use) & used)continue;
      bool ok = true;
      int dx = -minos[use][0].second;
      for(auto i:minos[use]){
        int y = i.first + poss[tp].first;
        int x = i.second + poss[tp].second + dx;
        if(y < 0 or 4 <= y){
          ok = false;
          break;
        }
        if(x < 0 or 10 <= x){
          ok = false;
          break;
        }
        if(table[y][x]=='#'){
          ok = false;
          break;
        }
      }
      if(ok){
        for(auto i:minos[use]){
          int y = i.first + poss[tp].first;
          int x = i.second + poss[tp].second + dx;
          table[y][x] = '#';
        }
        if(rec(rec,tp+1,used | (1<<use),used_count+1)){
          return true;
        }
        for(auto i:minos[use]){
          int y = i.first + poss[tp].first;
          int x = i.second + poss[tp].second + dx;
          table[y][x] = '.';
        }
      }
    }
    return false;
  };
  return rec(rec,0, 0, 0);
}

int main(){
  vector<vector<P>> minos(4);
  for(int i=0;i<4;++i)minos[i]=input_mino();
  int n;
  cin >> n;
  for(int i=0;i<n;++i){
    cout << (func(minos) ? "Yes": "No") << endl;
  }
}
accuracy: 1
time_ms: 180
memory_kb: 3460
final_rank: 10

code_snippet: #include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
using p = pair<int, int>;

vector<string> t[4];
vector<string> s;
vector<p> memo[4];
vector<int> h, w;
int n;

bool solve();
bool isblock(p now, int id) {
  return now.fi >= 0 && now.fi < h[id] && now.se >= 0 &&
         now.se < w[id] && t[id][now.fi][now.se] == '#';
}
bool isvalid(p now) {
  return now.fi >= 0 && now.fi < 4 && now.se >= 0 &&
         now.se < 10 && s[now.fi][now.se] == '.';
}
void prepair();

int main() {
  h.resize(4);
  w.resize(4);
  for(int i = 0; i < 4; ++i) {
    cin >> h[i] >> w[i];
    t[i].resize(h[i]);
    for(int j = 0; j < h[i]; ++j) cin >> t[i][j];
  }
  prepair();
  cin >> n;
  for(int i = 0; i < n; ++i) {
    s.resize(4);
    for(int j = 0; j < 4; ++j) cin >> s[j];
    if(solve())
      cout << "Yes" << endl;
    else
      cout << "No" << endl;
  }
  return 0;
}

void prepair() {
  int d[4] = {0, 1, 0, -1};
  for(int i = 0; i < 4; ++i) {
    for(int y = 0; y < w[i]; ++y)
      if(t[i][0][y] == '#') {
        queue<p> qu;
        qu.push({0, y});
        t[i][0][y] = '.';
        while(!qu.empty()) {
          p now = qu.front();
          qu.pop();
          memo[i].push_back({now.fi, now.se - y});
          for(int j = 0; j < 4; ++j) {
            p nextp = now;
            nextp.fi += d[j];
            nextp.se += d[j ^ 1];
            if(isblock(nextp, i)) {
              t[i][nextp.fi][nextp.se] = '.';
              qu.push(nextp);
            }
          }
        }
        break;
      }
  }
}

bool solve() {
  vector<int> perm(4);
  for(int i = 0; i < 4; ++i) perm[i] = i;
  do {
    vector<p> lst;
    int id = 0;
    bool ch = 1;
    for(int i = 0; i < 4; ++i)
      if(ch)
        for(int j = 0; j < 10; ++j)
          if(ch)
            if(s[i][j] == '.') {
              for(int k = 0; k < 4; ++k) {
                p nowb = {i + memo[perm[id]][k].fi,
                          j + memo[perm[id]][k].se};
                if(isvalid(nowb)) {
                  lst.push_back(nowb);
                  s[nowb.fi][nowb.se] = '#';
                }
                else
                  ch = 0;
              }
              ++id;
            }
    if(id == 3 && ch)
      return 1;
    else
      for(int i = 0; i < lst.size(); ++i)
        s[lst[i].fi][lst[i].se] = '.';
  } while(next_permutation(perm.begin(), perm.end()));
  return 0;
}
accuracy: 1
time_ms: 410
memory_kb: 3220
final_rank: 15

code_snippet: #include <cstdio>


int dx[4][4],dy[4][4];

char board[6][12];//y x

char buf[7][7];

bool DFS(int posy,int posx,int level,int mask){
    if (level==4) return true;

    for(;posy<4;posy++)
        for(posx=0;posx<10;posx++)
            if (board[posy][posx]=='.') goto end;
    end:

    for(int puzzle=0;puzzle<4;puzzle++){
        if (mask&(1<<puzzle)) continue;

        bool fits=true;
        for(int i=0;i<4;i++){
            int x=posx+dx[puzzle][i],y=posy+dy[puzzle][i];

            if (x<0||x>=10||y<0||y>=4||board[y][x]=='#') {
                fits=false;
                break;
            }
        }

        if (fits){
            for(int i=0;i<4;i++){
                int x=posx+dx[puzzle][i],y=posy+dy[puzzle][i];
                board[y][x]='#';
            }

            if (DFS(posy,posx,level+1,mask+(1<<puzzle))) return true;

            for(int i=0;i<4;i++){
                int x=posx+dx[puzzle][i],y=posy+dy[puzzle][i];
                board[y][x]='.';
            }
        }

    } 

    return false;
}

int main(){

    for(int i=0;i<4;i++){
        int h,w;
        scanf("%d%d\n",&h,&w);
        for(int i=1;i<=h;i++) scanf("%s",buf[i]+1);

        int fsty=1,fstx=1;
        for(fstx=1;buf[1][fstx]!='#';fstx++); 
        
        for(int j=1,cur=0;j<=h;j++)
            for(int k=1;k<=w;k++)
                if (buf[j][k]=='#'){
                    dx[i][cur]=k-fstx;
                    dy[i][cur]=j-fsty;
                    cur++;
                }
    }

    int N;
    scanf("%d\n",&N);
    for(int i=0;i<N;i++){
        for(int i=0;i<4;i++) scanf("%s",board[i]);

        if (DFS(0,0,1,0)) puts("Yes");
        else
            puts("No");
        
    }

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 2696
final_rank: 1

code_snippet: #include <cstdio>


int dx[4][4],dy[4][4];

char board[6][12];//y x

char buf[7][7];

bool DFS(int posy,int posx,int level,int mask){
    if (level==4) return true;
    // printf("posy=%d posx=%d\n",posy,posx);

    for(;posy<4;posy++)
        for(posx=0;posx<10;posx++)
            if (board[posy][posx]=='.') goto end;
    end: 
    // printf("posy=%d posx=%d\n",posy,posx);

    // for(int i=0;i<4;i++) puts(board[i]);

    for(int puzzle=0;puzzle<4;puzzle++){
        if (mask&(1<<puzzle)) continue;


        bool fits=true;
        for(int i=0;i<4;i++){
            int x=posx+dx[puzzle][i],y=posy+dy[puzzle][i];

            if (x<0||x>=10) {
                fits=false;
                break;
            }
            if (y<0||y>=4) {
                fits=false;
                break;
            }
            if (board[y][x]=='#'){
                fits=false;
                break;
            }
        }

        if (fits){
            for(int i=0;i<4;i++){
                int x=posx+dx[puzzle][i],y=posy+dy[puzzle][i];
                board[y][x]='#';
            }

            if (DFS(posy,posx,level+1,mask+(1<<puzzle))) return true;

            for(int i=0;i<4;i++){
                int x=posx+dx[puzzle][i],y=posy+dy[puzzle][i];
                board[y][x]='.';
            }
        }

    } 

    return false;
}

int main(){

    for(int i=0;i<4;i++){
        int h,w;
        scanf("%d%d\n",&h,&w);
        for(int i=1;i<=h;i++) scanf("%s",buf[i]+1);

        int fsty=1,fstx=1;
        for(fstx=1;buf[1][fstx]!='#';fstx++); 

        // printf("fst %d %d\n",fstx,fsty);
        
        for(int j=1,cur=0;j<=h;j++){
            for(int k=1;k<=w;k++){
                if (buf[j][k]=='#'){
                    dx[i][cur]=k-fstx;
                    dy[i][cur]=j-fsty;
                    cur++;
                }
            }
        }
    }

    int N;
    scanf("%d\n",&N);
    for(int i=0;i<N;i++){
        for(int i=0;i<4;i++) scanf("%s",board[i]);

        if (DFS(0,0,1,0)) puts("Yes");
        else
            puts("No");
        
        
    }

    // for(int i=0;i<4;i++){
    //     for(int j=0;j<4;j++)
    //         printf("(%d,%d)\n",dx[i][j],dy[i][j]);
    // }

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 2696
final_rank: 1

code_snippet: #include <cstdio>
#include <utility>

using namespace std;

char board[4][10];

typedef pair<int, int> coordinate;

struct puzzle{
    int h,w;
    char content[5][5];

    coordinate leftup;

    void find_upleft(){
        for(int i=0;i<h;i++)
            for (int j=0;j<w;j++)
                if (content[i][j]=='#') {
                    leftup=coordinate(i,j);
                    goto out;
                }
        out:
        ;
        // printf("h=%d w=%d",h,w);
        // printf("leftup %d %d",leftup.first,leftup.second);
    }

    bool fit(const coordinate& co){
        // 盤面から出ることを判定する
        if (co.first<0||co.second<0)
            return false;

        // puts("pass1");
        
        //co=(Y,X)
        if (co.first+h>4||co.second+w>10)
            return false;

        // puts("pass2");

        // 重なる部分を判定する
        for (int i=0;i<h;i++)
            for (int j=0;j<w;j++){
                // printf("(%d,%d)", co.first + i, co.second + j);
                if (board[co.first+i][co.second+j]=='#'&&content[i][j]=='#')
                {/*printf("i=%d,j=%d\n",i,j);*/return false;}

                
            }

        return true;
    }

    void draw(coordinate pos){
        for (int i=0;i<h;i++)
            for (int j=0;j<w;j++)
                if (board[pos.first+i][pos.second+j]=='.')
                    board[pos.first + i][pos.second + j] = content[i][j];
    }

    void undraw(coordinate pos){
        for (int i = 0; i < h; i++)
            for (int j = 0; j < w; j++)
                if (content[i][j]=='#')
                    board[pos.first + i][pos.second + j] = '.';
    }
}t[4];

// 対応するパズルは使われたか
bool used[4];

void init_t(int i){
    // パズルを初期化
    scanf("%d%d", &t[i].h, &t[i].w);
    getchar();
    for (int k = 0; k < t[i].h; k++)
    {
        for (int j = 0; j < t[i].w; j++)
            t[i].content[k][j] = getchar();

        getchar();
    }

    t[i].find_upleft();

    // printf("(%d,%d)\n",t[i].leftup.first,t[i].leftup.second);
    used[i]=false;

    // for (int k = 0; k < t[i].h; k++)
    // {
    //     for (int j = 0; j < t[i].w; j++)
    //         putchar(t[i].content[k][j]) ;

    //     putchar('\n');
    // }
}

void init_board(){
    //　盤面を初期化
    for(int i=0;i<4;i++){
        for(int j=0;j<10;j++)
            board[i][j]=getchar();

        getchar();
    }
}

coordinate find_upleft_board(){
    // 盤面の一番左上の空白を探す
    for (int i=0;i<4;i++)
        for (int j=0;j<10;j++)
            if (board[i][j]=='.') return coordinate(i,j);
}


void draw_board(){
    for (int i=0;i<4;i++){
        for(int j=0;j<10;j++)
            putchar(board[i][j]);
        putchar('\n');
    }
}

bool solve(int puzzle_used){
    if (puzzle_used>=3)
        return true;


    coordinate leftup=find_upleft_board();
    // printf("%d %d\n",leftup.first,leftup.second);

    for (int i=0;i<4;i++){
        //既に使ったパズルは使わない
        if (used[i])
            continue;

        // if (i==2)
        //     puts("hello"),draw_board();

        //　パズルのポジションを探す
        coordinate puzzle_pos=coordinate(
            leftup.first-t[i].leftup.first,
            leftup.second-t[i].leftup.second
        );

        // printf("(%d,%d) i=%d\n", puzzle_pos.first, puzzle_pos.second, i);
        // printf("i=%d\n",i);
        if (t[i].fit(puzzle_pos)){
            // printf("puzzle_used=%d\n", puzzle_used);
            // draw_board();
            t[i].draw(puzzle_pos);
            used[i]=true;
            // draw_board();
            if (solve(puzzle_used+1)) return true;
            //元にする
            t[i].undraw(puzzle_pos);
            used[i]=false;
        }
    }

    return false;
}

int main(){

    for (int i=0;i<4;i++) init_t(i);

    int n;
    scanf("%d",&n);
    getchar();

    for(int i=0;i<n;i++){
        init_board();
        // printf("fits? %d\n",t[2].fit(coordinate(0,4)));
        for(int i=0;i<4;i++) used[i]=false;
        bool t=solve(0);
        if (t)
            puts("Yes");
        else
            puts("No");
    }



    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 2692
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;

int H[4], W[4];
int S[4][4][4] = {0};

bool solve(){
    int A[4][10] = {0};
    for(int i=0; i<4; i++){
        string s;
        cin >> s;
        for(int j=0; j<10; j++) if(s[j] == '#') A[i][j] = 1;
    }

    vector<pair<int, int>> avail[4];
    for(int k=0; k<4; k++){
        for(int i=0; i<=4-H[k]; i++) for(int j=0; j<=10-W[k]; j++){
            bool ok = true;
            for(int x=0; x<H[k]; x++) for(int y=0; y<W[k]; y++) if(S[k][x][y] && A[i+x][j+y]) ok = false;
            if(ok) avail[k].emplace_back(i, j);
        }
    }

    for(int ex=0; ex<4; ex++){
        vector<int> use;
        for(int k=0; k<4; k++) if(k != ex) use.push_back(k);

        for(auto& p0 : avail[use[0]]){
            bool ok0 = true;
            int i0 = p0.first, j0 = p0.second, k0 = use[0];
            for(int x=0; x<H[k0]; x++) for(int y=0; y<W[k0]; y++) if(S[k0][x][y]) {
                A[i0+x][j0+y]++;
                if(A[i0+x][j0+y] > 1) ok0 = false;
            }

            if(ok0) for(auto& p1 : avail[use[1]]){
                bool ok1 = true;
                int i1 = p1.first, j1 = p1.second, k1 = use[1];
                for(int x=0; x<H[k1]; x++) for(int y=0; y<W[k1]; y++) if(S[k1][x][y]){
                    A[i1+x][j1+y]++;
                    if(A[i1+x][j1+y] > 1) ok1 = false;
                }

                if(ok1) for(auto& p2 : avail[use[2]]){
                    bool ok2 = true;
                    int i2 = p2.first, j2 = p2.second, k2 = use[2];
                    for(int x=0; x<H[k2]; x++) for(int y=0; y<W[k2]; y++) if(S[k2][x][y]){
                        A[i2+x][j2+y]++;
                        if(A[i2+x][j2+y] > 1) ok2 = false;
                    }
                    if(ok2) return true;
                    for(int x=0; x<H[k2]; x++) for(int y=0; y<W[k2]; y++) if(S[k2][x][y]){
                        A[i2+x][j2+y]--;
                    }
                }

                for(int x=0; x<H[k1]; x++) for(int y=0; y<W[k1]; y++) if(S[k1][x][y]){
                    A[i1+x][j1+y]--;
                }
            }

            for(int x=0; x<H[k0]; x++) for(int y=0; y<W[k0]; y++) if(S[k0][x][y]){
                A[i0+x][j0+y]--;
            }
        }
    }
    return false;
}

int main(){
    for(int k=0; k<4; k++){
        cin >> H[k] >> W[k];
        for(int i=0; i<H[k]; i++){
            string s;
            cin >> s;
            for(int j=0; j<W[k]; j++) if(s[j] == '#') S[k][i][j] = 1;
        }
    }
    int N;
    cin >> N;
    while(N--) cout << (solve() ? "Yes" : "No") << endl;
    return 0;
}
accuracy: 1
time_ms: 390
memory_kb: 3216
final_rank: 14

code_snippet: #include <bits/stdc++.h>
using namespace std;

int H[4], W[4];
int S[4][4][4] = {0};

bool solve(){
    int A[4][10] = {0};
    for(int i=0; i<4; i++){
        string s;
        cin >> s;
        for(int j=0; j<10; j++) if(s[j] == '#') A[i][j] = 1;
    }

    vector<pair<int, int>> avail[4];
    for(int k=0; k<4; k++){
        for(int i=0; i<=4-H[k]; i++) for(int j=0; j<=10-W[k]; j++){
            bool ok = true;
            for(int x=0; x<H[k]; x++) for(int y=0; y<W[k]; y++) if(S[k][x][y] && A[i+x][j+y]) ok = false;
            if(ok) avail[k].emplace_back(i, j);
        }
    }

    for(int ex=0; ex<4; ex++){
        vector<int> use;
        for(int k=0; k<4; k++) if(k != ex) use.push_back(k);

        for(auto& p0 : avail[use[0]]){
            bool ok0 = true;
            int i0 = p0.first, j0 = p0.second, k0 = use[0];
            for(int x=0; x<H[k0]; x++) for(int y=0; y<W[k0]; y++) if(S[k0][x][y]) {
                A[i0+x][j0+y]++;
                if(A[i0+x][j0+y] > 1) ok0 = false;
            }

            if(ok0) for(auto& p1 : avail[use[1]]){
                bool ok1 = true;
                int i1 = p1.first, j1 = p1.second, k1 = use[1];
                for(int x=0; x<H[k1]; x++) for(int y=0; y<W[k1]; y++) if(S[k1][x][y]){
                    A[i1+x][j1+y]++;
                    if(A[i1+x][j1+y] > 1) ok1 = false;
                }

                if(ok1) for(auto& p2 : avail[use[2]]){
                    bool ok2 = true;
                    int i2 = p2.first, j2 = p2.second, k2 = use[2];
                    for(int x=0; x<H[k2]; x++) for(int y=0; y<W[k2]; y++) if(S[k2][x][y]){
                        A[i2+x][j2+y]++;
                        if(A[i2+x][j2+y] > 1) ok1 = false;
                    }
                    if(ok2) return true;
                    for(int x=0; x<H[k2]; x++) for(int y=0; y<W[k2]; y++) if(S[k2][x][y]){
                        A[i2+x][j2+y]--;
                    }
                }

                for(int x=0; x<H[k1]; x++) for(int y=0; y<W[k1]; y++) if(S[k1][x][y]){
                    A[i1+x][j1+y]--;
                }
            }

            for(int x=0; x<H[k0]; x++) for(int y=0; y<W[k0]; y++) if(S[k0][x][y]){
                A[i0+x][j0+y]--;
            }
        }
    }
    return false;
}

int main(){
    for(int k=0; k<4; k++){
        cin >> H[k] >> W[k];
        for(int i=0; i<H[k]; i++){
            string s;
            cin >> s;
            for(int j=0; j<W[k]; j++) if(s[j] == '#') S[k][i][j] = 1;
        }
    }
    int N;
    cin >> N;
    while(N--) cout << (solve() ? "Yes" : "No") << endl;
    return 0;
}
accuracy: 0.40625
time_ms: 10
memory_kb: 3180
final_rank: 20

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}


struct FastIO{
  FastIO(){
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
}fastio_beet;

//INSERT ABOVE HERE
struct Mino{
  Int h,w;
  vector<string> vs;
};
vector<Mino> ms(4);

const Int H=4,W=10;
set< vector<string> > cs;
vector<string> bs(H,string(W,'#')),st;

void fill(Mino m,Int k){
  Int y=k/W,x=k%W;
  if(y+m.h>H||x+m.w>W) return;
  for(Int i=0;i<m.h;i++)
    for(Int j=0;j<m.w;j++)
      if(m.vs[i][j]=='#') st[y+i][x+j]='.';
}

void solve(){
  for(Int i=0;i<4;i++){
    for(Int j=0;j<i;j++){
      for(Int k=0;k<j;k++){
        for(Int a=0;a<40;a++){
          for(Int b=0;b<40;b++){
            for(Int c=0;c<40;c++){
              st=bs;
              fill(ms[i],a);
              fill(ms[j],b);
              fill(ms[k],c);

              //for(int p=0;p<H;p++) cout<<st[p]<<endl;
              //cout<<endl;

              cs.emplace(st);
            }
          }
        }
      }
    }
  }
}

signed main(){
  for(Int i=0;i<4;i++){
    cin>>ms[i].h>>ms[i].w;
    ms[i].vs.resize(ms[i].h);
    for(Int j=0;j<ms[i].h;j++)
      cin>>ms[i].vs[j];

    if(0){
      for(Int j=0;j<ms[i].h;j++)
        cout<<ms[i].vs[j]<<endl;
      cout<<endl;
    }
  }
  solve();

  Int n;
  cin>>n;
  for(Int i=0;i<n;i++){
    vector<string> st(4);
    for(Int j=0;j<4;j++) cin>>st[j];
    if(cs.count(st)) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
  }
  return 0;
}
accuracy: 1
time_ms: 410
memory_kb: 18220
final_rank: 19

code_snippet: /*  -*- coding: utf-8 -*-
 *
 * 3108.cc: Perfect
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_H = 4;
const int MAX_W = 4;
const int M = 4;
const int BH = 4;
const int BW = 10;

/* typedef */

typedef vector<int> vi;
typedef queue<int> qi;
typedef pair<int,int> pii;

struct Tetro {
  int h, w;
  char cs[MAX_H][MAX_W + 4];
  Tetro() {}

  void read() {
    scanf("%d%d", &h, &w);
    for (int y = 0; y < h; y++) scanf("%s", cs[y]);
  }
};

struct Board {
  char bs[BH][BW + 4];
  Board() {}

  void read() {
    for (int y = 0; y < BH; y++) scanf("%s", bs[y]);
  }

  bool fit(Tetro &t, int x0, int y0) {
    if (y0 + t.h > BH || x0 + t.w > BW) return false;
    for (int ty = 0, by = y0; ty < t.h; ty++, by++)
      for (int tx = 0, bx = x0; tx < t.w; tx++, bx++)
	if (t.cs[ty][tx] == '#' && bs[by][bx] == '#') return false;
    return true;
  }

  void set(Tetro &t, int x0, int y0, char c) {
    for (int ty = 0, by = y0; ty < t.h; ty++, by++)
      for (int tx = 0, bx = x0; tx < t.w; tx++, bx++)
	if (t.cs[ty][tx] == '#') bs[by][bx] = c;
  }
  void set(Tetro &t, int x0, int y0) { set(t, x0, y0, '#'); }
  void unset(Tetro &t, int x0, int y0) { set(t, x0, y0, '.'); }
};

/* global variables */


Tetro ts[M];
Board bd;

/* subroutines */

bool check(int k, int u) {
  if (k >= M) return (u >= M - 1);

  Tetro &tk = ts[k];
  if (check(k + 1, u)) return true;

  for (int y0 = 0; y0 + tk.h <= BH; y0++)
    for (int x0 = 0; x0 + tk.w <= BW; x0++)
      if (bd.fit(tk, x0, y0)) {
	bd.set(tk, x0, y0);
	if (check(k + 1, u + 1)) return true;
	bd.unset(tk, x0, y0);
      }
  return false;
}

/* main */

int main() {
  for (int i = 0; i < M; i++) ts[i].read();

  int n;
  scanf("%d", &n);

  while (n--) {
    bd.read();

    if (check(0, 0)) puts("Yes");
    else puts("No");
  }
  return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 3168
final_rank: 7

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


struct LOC{
	LOC(int arg_row,int arg_col){

		row = arg_row;
		col = arg_col;
	}
	int row,col;
};

struct Info{

	vector<LOC> loc;
};

int H[4],W[4];
char table[4][4][5];
char base_map[4][11];
Info info[4];


bool rangeCheck(int row,int col){

	return row >= 0 && row <= 3 && col >= 0 && col <= 9;
}


bool is_OK(){

	vector<LOC> work;

	for(int not_use = 0; not_use < 4; not_use++){

		int perm[3];
		int index = 0;
		for(int i = 0; i < 4; i++){
			if(i == not_use)continue;

			perm[index++] = i;
		}

		do{

			bool tmp_FLG;
			index = 0;

			tmp_FLG = true;

			for(int row = 0; row < 4; row++){
				for(int col = 0; col < 10; col++){
					if(base_map[row][col] == '#')continue;

					base_map[row][col] = '#';
					work.push_back(LOC(row,col));

					for(int i = 0; i < 3; i++){

						int adj_row = row+info[perm[index]].loc[i].row;
						int adj_col = col+info[perm[index]].loc[i].col;

						if(rangeCheck(adj_row,adj_col) == false || base_map[adj_row][adj_col] == '#'){

							tmp_FLG = false;
							break;
						}
						base_map[adj_row][adj_col] = '#';
						work.push_back(LOC(adj_row,adj_col));
					}

					if(!tmp_FLG)break;

					index++;
				}
				if(!tmp_FLG)break;
			}

			if(index == 3)return true;

			for(int i = 0; i < work.size(); i++){

				base_map[work[i].row][work[i].col] = '.';
			}

			work.clear();

		}while(next_permutation(perm,perm+3));
	}

	return false;
}

int main(){

	for(int i = 0; i < 4; i++){

		scanf("%d %d",&H[i],&W[i]);

		for(int row = 0; row < H[i];row++){

			scanf("%s",table[i][row]);
		}

		//基準点からの相対位置を記録しておく
		for(int col = 0; col < W[i]; col++){

			if(table[i][0][col] == '#'){

				for(int diff_row = 0; diff_row < 4; diff_row++){
					if(diff_row >= H[i])continue;
					for(int diff_col = -3; diff_col < 4; diff_col++){
						if(col+diff_col < 0 || col+diff_col >= W[i])continue;

						if(diff_row != 0 || diff_col != 0){
							if(table[i][diff_row][col+diff_col] == '#'){

								info[i].loc.push_back(LOC(diff_row,diff_col));
							}
						}
					}
				}
				break;
			}
		}
	}

	int num_query;

	scanf("%d",&num_query);

	for(int loop = 0; loop < num_query; loop++){

		for(int row = 0; row < 4; row++){

			scanf("%s",base_map[row]);
		}

		if(is_OK()){

			printf("Yes\n");

		}else{

			printf("No\n");
		}
	}

	return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 3160
final_rank: 6

code_snippet: #include <bits/stdc++.h>
#define GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
#define pr(...) cerr<< GET_MACRO(__VA_ARGS__,pr8,pr7,pr6,pr5,pr4,pr3,pr2,pr1)(__VA_ARGS__) <<endl
#define pr1(a) (#a)<<"="<<(a)<<" "
#define pr2(a,b) pr1(a)<<pr1(b)
#define pr3(a,b,c) pr1(a)<<pr2(b,c)
#define pr4(a,b,c,d) pr1(a)<<pr3(b,c,d)
#define pr5(a,b,c,d,e) pr1(a)<<pr4(b,c,d,e)
#define pr6(a,b,c,d,e,f) pr1(a)<<pr5(b,c,d,e,f)
#define pr7(a,b,c,d,e,f,g) pr1(a)<<pr6(b,c,d,e,f,g)
#define pr8(a,b,c,d,e,f,g,h) pr1(a)<<pr7(b,c,d,e,f,g,h)
#define prArr(a) {cerr<<(#a)<<"={";int i=0;for(auto t:(a))cerr<<(i++?", ":"")<<t;cerr<<"}"<<endl;}
using namespace std;
using Int = long long;
using _int = int;
using ll = long long;
using Double = long double;
const Int INF = (1LL<<60)+1e9; // ~ 1.15 * 1e18
const Int mod = (1e9)+7;
const Double EPS = 1e-8;
const Double PI = 6.0 * asin((Double)0.5);
using P = pair<Int,Int>;
template<class T> T Max(T &a,T b){return a=max(a,b);}
template<class T> T Min(T &a,T b){return a=min(a,b);}
template<class T1, class T2> ostream& operator<<(ostream& o,pair<T1,T2> p){return o<<"("<<p.first<<","<<p.second<<")";}
template<class T1, class T2, class T3> ostream& operator<<(ostream& o,tuple<T1,T2,T3> t){
  return o<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<")";}
template<class T1, class T2> istream& operator>>(istream& i,pair<T1,T2> &p){return i>>p.first>>p.second;}
template<class T> ostream& operator<<(ostream& o,vector<T> a){Int i=0;for(T t:a)o<<(i++?" ":"")<<t;return o;}
template<class T> istream& operator>>(istream& i,vector<T> &a){for(T &t:a)i>>t;return i;}
//INSERT ABOVE HERE



signed main(){
  srand((unsigned)time(NULL));
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  vector<string> t[4];
  for(int i=0;i<4;i++){
    int h, w;
    cin>>h>>w;
    t[i].resize(h);
    cin>>t[i];
  }

  int n;
  cin>>n;
  for(int num_case=0;num_case<n;num_case++){
    const int H = 4, W = 10;
    vector<string> mp(H);
    cin>>mp;

    {
      int cnt = 0;
      for(int i=0;i<H;i++)
        for(int j=0;j<W;j++) cnt += mp[i][j] == '.';
      if(cnt != 12) {cout<<"No"<<endl;continue;}
    }



    auto check =[&](int y, int x, vector<string> &s){
      int h = s.size(), w = s[0].size();
      if(y + h > H || x + w > W) return 0;
      for(int i=0;i<h;i++)
        for(int j=0;j<w;j++){
          if(s[i][j] == '#' && mp[y + i][x + j] == '#') return 0;
        }
      return 1;
    };

    auto ume = [&](int y, int x, vector<string> &s, int erase){
      int h = s.size(), w = s[0].size();
      for(int i=0;i<h;i++)
        for(int j=0;j<w;j++)
          if(s[i][j] == '#') mp[y + i][x + j] = erase? '.':'#';
    };

    function<int(int, int)> dfs = [&](int idx, int ng){

      if(idx == 4){
        for(int i=0;i<H;i++)
          for(int j=0;j<W;j++) if(mp[i][j] != '#') return 0;
        return 1;
      }

      if(idx == ng) return dfs(idx + 1, ng);
      for(int i=0;i<H;i++)
        for(int j=0;j<W;j++){
          if(!check(i, j, t[idx])) continue;
          ume(i, j, t[idx], 0);
          if(dfs(idx + 1, ng)) return 1;
          ume(i, j, t[idx], 1);
        }
      return 0;
    };

    int ans = 0;
    for(int i=0;i<4 && ans == 0;i++) ans |= dfs(0, i);
    cout<<(ans? "Yes":"No")<<endl;
  }

  return 0;
}
accuracy: 1
time_ms: 250
memory_kb: 3212
final_rank: 11

code_snippet: #include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
using namespace std;

int main(){
    vector<int> h(4), w(4);
    vector< vector<string> > s(4, vector<string>(4));
    for(int i=0; i<4; i++){
        cin>>h[i]>>w[i];
        vector<string> S(h[i]);
        for(int j=0; j<h[i]; j++){
            cin>>S[j];
        }
        s[i] = S;
    }

    set<vector<string>> exist;

    vector<int> v = {0, 1, 1, 1};
    do{
        vector<int> useid;
        for(int i=0; i<4; i++){
            if(v[i] == 1) useid.emplace_back(i);
        }

        int aid = useid[0];
        int bid = useid[1];
        int cid = useid[2];

        for(int ax=0; ax+w[aid]-1<10; ax++){
            for(int ay=0; ay+h[aid]-1<4; ay++){
                for(int bx=0; bx+w[bid]-1<10; bx++){
                    for(int by=0; by+h[bid]-1<4; by++){
                        for(int cx=0; cx+w[cid]-1<10; cx++){
                            for(int cy=0; cy+h[cid]-1<4; cy++){
                                
                                vector<string> ban(4);
                                for(int i=0; i<4; i++){
                                    ban[i] = "..........";
                                }

                                int ayt = ay + h[aid] - 1;
                                int axt = ax + w[aid] - 1;
                                int byt = by + h[bid] - 1;
                                int bxt = bx + w[bid] - 1;
                                int cyt = cy + h[cid] - 1;
                                int cxt = cx + w[cid] - 1;

                                bool valid = true;
                                for(int ady=ay; ady<=ayt; ady++){
                                    for(int adx=ax; adx<=axt; adx++){
                                        if(ban[ady][adx] == '#'){
                                            if(s[aid][ady-ay][adx-ax] == '.');
                                            else valid = false;
                                        }
                                        else{
                                            ban[ady][adx] = s[aid][ady-ay][adx-ax];
                                        }

                                        if(!valid) break;
                                    }
                                    
                                    if(!valid) break;
                                }

                                if(!valid) continue;

                                for(int bdy=by; bdy<=byt; bdy++){
                                    for(int bdx=bx; bdx<=bxt; bdx++){
                                        if(ban[bdy][bdx] == '#'){
                                            if(s[bid][bdy-by][bdx-bx] == '.');
                                            else valid = false;
                                        }
                                        else{
                                            ban[bdy][bdx] = s[bid][bdy-by][bdx-bx];
                                        }

                                        if(!valid) break;
                                    }

                                    if(!valid) break;
                                }

                                if(!valid) continue;

                                for(int cdy=cy; cdy<=cyt; cdy++){
                                    for(int cdx=cx; cdx<=cxt; cdx++){
                                        if(ban[cdy][cdx] == '#'){
                                            if(s[cid][cdy-cy][cdx-cx] == '.');
                                            else valid = false;
                                        }
                                        else{
                                            ban[cdy][cdx] = s[cid][cdy-cy][cdx-cx];
                                        }

                                        if(!valid) break;
                                    }

                                    if(!valid) break;
                                }

                                if(!valid) continue;

                                for(int i=0; i<4; i++){
                                    for(int j=0; j<10; j++){
                                        ban[i][j] = (ban[i][j] == '.' ? '#' : '.');
                                    }
                                }

                                exist.emplace(ban);
                            }
                        }
                    }
                }
            }
        }
    }while(next_permutation(v.begin(), v.end()));

    int n; cin>>n;
    while(n--){
        vector<string> B(4);
        for(int i=0; i<4; i++) cin>>B[i];

        if(exist.count(B)) cout << "Yes" << endl;
        else cout << "No" << endl;
    }
}
accuracy: 1
time_ms: 340
memory_kb: 9548
final_rank: 18

code_snippet: #include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <stdio.h>
using namespace std;
#define int long long
int MOD = 1000000007;

int tobit(vector<string> &S) {
	int res = 0;
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 10; j++) {
			res <<= 1;
			if (S[i][j] == '.') {
				res++;
			}
		}
	}
	return res;
}
signed main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	set<int> st;
	vector<vector<string> > A(4);
	for (int i = 0; i < 4; i++) {
		int h, w;
		cin >> h >> w;
		A[i].resize(h);
		for (int j = 0; j < h; j++) {
			cin >> A[i][j];
		}
	}
	vector<vector< vector<pair<int, int> > > > t(4);
	for (int i = 0; i < 4; i++) {
		vector<pair<int, int> > vp;
		for (int j = 0; j < A[i].size(); j++) {
			for (int k = 0; k < A[i][0].size(); k++) {
				if (A[i][j][k] == '#') {
					vp.emplace_back(j, k);
				}
			}
		}
	
		for (int j = 0; j < 4; j++) {
			for (int k = 0; k < 10; k++) {
				bool ok = true;
				vector<pair<int, int> > tmp;
				for (int a = 0; a < 4; a++) {
					if (j + vp[a].first >= 4)ok = false;
					if (k + vp[a].second >= 10)ok = false;
					tmp.emplace_back(j + vp[a].first, k + vp[a].second);
				}
				if (ok) {
					t[i].push_back(tmp);
				}
			}
		}
	}
	//cerr << "OK" << endl;
	for (int i = 0; i < 4; i++) {
		vector<int> X;
		for (int j = 0; j < 4; j++) {
			if (i != j) {
				X.push_back(j);
			}
		}

		int a[3];
		int cnt = 0;
		for (a[0] = 0; a[0] < t[X[0]].size(); a[0]++) {
			for (a[1] = 0; a[1] < t[X[1]].size(); a[1]++) {
				for (a[2] = 0; a[2] < t[X[2]].size(); a[2]++) {
					vector<string> S(4, string(10, '#'));
					bool ok = true;
					for (int j = 0; j < 4; j++) {
						for (int k = 0; k < 3; k++) {
							if (S[t[X[k]][a[k]][j].first][t[X[k]][a[k]][j].second] == '#') {
								S[t[X[k]][a[k]][j].first][t[X[k]][a[k]][j].second] = '.';
							}
							else {
								ok = false;
								break;
							}
						}
						if (!ok)break;
					}
					if (ok) {
						/*cnt++;
						if (cnt <= 10) {
							for (int j = 0; j < 4; j++) {
								cerr << S[j] << endl;
							}
							cerr << endl;
						}*/
						st.insert(tobit(S));
					}

				}
			}
		}
	}

	int Q;
	cin >> Q;
	for (int i = 0; i < Q; i++) {
		vector<string> S(4);
		for (int j = 0; j < 4; j++) {
			cin >> S[j];
		}
		int c = tobit(S);
		if (st.count(c) > 0) {
			cout << "Yes" << endl;
		}
		else {
			cout << "No" << endl;
		}
	}



}
accuracy: 1
time_ms: 130
memory_kb: 4196
final_rank: 9

code_snippet: #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>

#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>

#include <functional>
#include <cassert>

typedef long long ll;
using namespace std;

#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;

template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << "{" << p.first << ", " << p.second << "}";
  return out;
}

template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
  out << '{';
  for (const T &item : v) out << item << ", ";
  out << "\b\b}";
  return out;
}
#endif

#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 200010

const int H = 4;
const int W = 10;

int minoH[4], minoW[4];
char mino[4][4][5];

bool A[4][11];

set<ll> ss;

void gen(int now = 0, int use = 0) {

  if (use == now) gen(now+1, use);

  if (use >= 3) {
    ll bit = 0;

    for(int i=0; i<H; i++)
      for(int j=0; j<W; j++)
        bit = (bit << 1) + A[i][j];

    assert(__builtin_popcountll(bit) == 4 * 3);
    ss.insert(bit);

    return;

  } else {
    for(int y=0; y+minoH[now]<=4; y++) {
      for(int x=0; x+minoW[now]<=10; x++) {
        bool ok = true;

        for(int i=0; i<minoH[now]; i++)
          for(int j=0; j<minoW[now]; j++)
            ok &= !A[y+i][x+j] || mino[now][i][j] == '.';

        if (!ok) continue;

        for(int i=0; i<minoH[now]; i++)
          for(int j=0; j<minoW[now]; j++)
            A[y+i][x+j] |= mino[now][i][j] == '#';

        gen(now+1, use+1);

        for(int i=0; i<minoH[now]; i++)
          for(int j=0; j<minoW[now]; j++)
            A[y+i][x+j] ^= mino[now][i][j] == '#';
      }
    }

  }
}

int main(){
  int N;
  char B[4][11];

  for(int i=0; i<4; i++) {
    scanf("%d%d", minoH+i, minoW+i);

    for(int j=0; j<minoH[i]; j++)
      scanf("%s", mino[i][j]);
  }

  gen();

  debug(ss.size());

  scanf("%d", &N);

  for(int i=0; i<N; i++) {
    ll bit = 0;
    for(int j=0; j<H; j++) {
      scanf("%s", B[j]);

      debug(B[j]);
      for(int k=0; k<W; k++)
        bit = (bit << 1) + (B[j][k] == '#');
    }


    bit ^= (1LL << (W * H)) - 1;

    if (ss.find(bit) != ss.end()) {
      puts("Yes");
    } else {
      puts("No");
    }
  }

  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 4104
final_rank: 4

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <assert.h>
using namespace std;
typedef long long int ll;

int h[4];
int w[4];
vector<string> M[4];
int used[4][10];
char fi[4][10];

int main(){
    for(int i=0;i<4;i++){
        cin >> h[i] >> w[i];
        for(int j=0;j<h[i];j++){
            string s; cin >> s;
            M[i].push_back(s);
        }
    }
    set<string> st;
    for(int i=0;i<4;i++){
        vector<int> kouho;

        for(int j=0;j<4;j++){
            if(i!=j)kouho.push_back(j);
        }

        for(int j=0;j<40;j++){
            int a1=j/10,b1=j%10;
            if(a1+h[kouho[0]]>4||b1+w[kouho[0]]>10)continue;

            for(int k=0;k<40;k++){
                int a2=k/10,b2=k%10;
                if(a2+h[kouho[1]]>4||b2+w[kouho[1]]>10)continue;

                for(int l=0;l<40;l++){
                    int a3=l/10,b3=l%10;
                    if(a3+h[kouho[2]]>4||b3+w[kouho[2]]>10)continue;

                    for(int a=0;a<4;a++){
                        for(int b=0;b<10;b++){
                            fi[a][b]='#';
                        }
                    }
                    bool ok=true;
                    for(int y=0;y<h[kouho[0]];y++){
                        for(int x=0;x<w[kouho[0]];x++){
                            if(fi[a1+y][b1+x]=='#'&&M[kouho[0]][y][x]=='#'){
                                fi[a1+y][b1+x]='.';
                            }
                            else if(fi[a1+y][b1+x]=='.'&&M[kouho[0]][y][x]=='#'){
                                ok=false;
                            }
                        }
                    }
                    for(int y=0;y<h[kouho[1]];y++){
                        for(int x=0;x<w[kouho[1]];x++){
                            if(fi[a2+y][b2+x]=='#'&&M[kouho[1]][y][x]=='#'){
                                fi[a2+y][b2+x]='.';
                            }
                            else if(fi[a2+y][b2+x]=='.'&&M[kouho[1]][y][x]=='#'){
                                ok=false;
                            }
                        }
                    }
                    for(int y=0;y<h[kouho[2]];y++){
                        for(int x=0;x<w[kouho[2]];x++){
                            if(fi[a3+y][b3+x]=='#'&&M[kouho[2]][y][x]=='#'){
                                fi[a3+y][b3+x]='.';
                            }
                            else if(fi[a3+y][b3+x]=='.'&&M[kouho[2]][y][x]=='#'){
                                ok=false;
                            }
                        }
                    }
                    if(ok){
                        string s="";
                        for(int i=0;i<4;i++){
                            for(int j=0;j<10;j++){
                                s+=fi[i][j];
                            }
                        }
                        assert(s.size()==40);
                        st.insert(s);
                    }
                }
            }
        }
    }

    int n; cin >> n;
    for(int i=0;i<n;i++){
        string s="";
        for(int j=0;j<4;j++){
            string t; cin >> t;
            s+=t;
        }
        if(st.count(s)){
            cout << "Yes" << endl;
        }
        else{
            cout << "No" << endl;
        }
    }
}
accuracy: 1
time_ms: 320
memory_kb: 6652
final_rank: 16

code_snippet: #include <iostream>
#include <vector>
#include <array>
#include <functional>

using std::array;
using std::vector;

constexpr int H = 4, W = 10;

using Block = vector<vector<char>>;
using Board = array<array<char, W>, H>;

int main() {
    array<Block, 4> blocks;
    for (auto& block : blocks) {
        int h, w;
        std::cin >> h >> w;
        block.resize(h);
        for (auto& s : block) {
            s.resize(w);
            for (auto& c : s) {
                std::cin >> c;
            }
        }
    }

    int q;
    std::cin >> q;
    for (int i = 0; i < q; ++i) {
        Board board;
        for (auto& s : board) {
            for (auto& c : s) {
                std::cin >> c;
            }
        }

        std::function<bool(int)> dfs =
            [&](int idx) {
                if (idx == 4) {
                    for (int x = 0; x < H; ++x) {
                        for (int y = 0; y < W; ++y) {
                            if (board[x][y] == '.') {
                                return false;
                            }
                        }
                    }
                    return true;
                } else {
                    if (dfs(idx + 1)) return true;

                    auto& block = blocks[idx];
                    int h = block.size(), w = block.front().size();

                    for (int x = 0; x + h - 1 < H; ++x) {
                        for (int y = 0; y + w - 1 < W; ++y) {
                            bool puttable = true;

                            // check
                            for (int dx = 0; dx < h; ++dx) {
                                for (int dy = 0; dy < w; ++dy) {
                                    if (block[dx][dy] == '.') continue;
                                    if (board[x + dx][y + dy] != '.') puttable = false;
                                }
                            }

                            if (!puttable) continue;

                            // paint
                            for (int dx = 0; dx < h; ++dx) {
                                for (int dy = 0; dy < w; ++dy) {
                                    if (block[dx][dy] == '.') continue;
                                    board[x + dx][y + dy] = 'A' + idx;
                                }
                            }

                            bool result = dfs(idx + 1);

                            // reverse
                            for (int dx = 0; dx < h; ++dx) {
                                for (int dy = 0; dy < w; ++dy) {
                                    if (block[dx][dy] == '.') continue;
                                    board[x + dx][y + dy] = '.';
                                }
                            }

                            if (result) return true;
                        }
                    }
                    return false;
                }
            };

        std::cout << (dfs(0) ? "Yes" : "No") << std::endl;
    }
    return 0;
}
accuracy: 1
time_ms: 340
memory_kb: 3124
final_rank: 13

code_snippet: #if __has_include("../library/Basic/Debug.hpp")

#include "../library/Basic/Debug.hpp"

#else

/* ----- Header Files ----- */
// IO
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>

// algorithm
#include <algorithm>
#include <cmath>
#include <numeric>

// container
#include <vector>
#include <array>
#include <string>
#include <tuple>
#include <complex>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>

// others
#include <random>
#include <limits>
#include <functional>
#include <ctime>
#include <cassert>
#include <cstdint>

/* ----- Type Alias ----- */
using Int = long long int;
using Real = long double;
using std::array;
using std::pair;
using std::string;
using std::tuple;
using std::vector;
template <class T>
using MaxHeap = std::priority_queue<T>;
template <class T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;

template <class T>
T genv(T v) { return v; }

template <class T, class... Ts>
auto genv(size_t l, Ts... ts) {
    return vector<decltype(genv<T>(ts...))>(l, genv<T>(ts...));
}

template <class Cost = Int>
struct Edge {
    Int src, dst;
    Cost cost;
    Edge(Int src = -1, Int dst = -1, Cost cost = 1)
        : src(src), dst(dst), cost(cost){};

    bool operator<(const Edge<Cost>& e) const { return this->cost < e.cost; }
    bool operator>(const Edge<Cost>& e) const { return this->cost > e.cost; }
};

template <class Cost = Int>
using Edges = vector<Edge<Cost>>;
template <class Cost = Int>
using Graph = vector<vector<Edge<Cost>>>;

#endif

/* ----- Misc ----- */
void fastio() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
}

struct Fout {
    Int precision;
    Fout(Int precision) : precision(precision) {}
};
std::ostream& operator<<(std::ostream& os, const Fout& fio) {
    os << std::fixed << std::setprecision(fio.precision);
    return os;
}


/* ----- Constants ----- */
// constexpr Int INF = std::numeric_limits<Int>::max() / 3;
// constexpr Int MOD = 1000000007;
// const Real PI = acos(-1);
// constexpr Real EPS = 1e-10;
// std::mt19937 mt(int(std::time(nullptr)));

using Block = vector<string>;

int main() {
    array<Block, 4> blocks;
    for (auto& block : blocks) {
        int h, w;
        std::cin >> h >> w;
        block.resize(h);
        for (auto& s : block) std::cin >> s;
    }

    int q;
    std::cin >> q;
    vector<pair<int, int>> tmp;
    for (int i = 0; i < q; ++i) {
        Block board(4);
        for (auto& s : board) std::cin >> s;

        std::function<bool(int)> dfs =
            [&](int idx) {
                if (idx == 4) {
                    for (int x = 0; x < 4; ++x) {
                        for (int y = 0; y < 10; ++y) {
                            if (board[x][y] == '.') {
                                return false;
                            }
                        }
                    }
                    return true;
                } else {
                    if (dfs(idx + 1)) return true;

                    auto& block = blocks[idx];
                    int n = block.size(), m = block.front().size();

                    for (int x = 0; x + n - 1 < 4; ++x) {
                        for (int y = 0; y + m - 1 < 10; ++y) {
                            bool puttable = true;
                            for (int dx = 0; dx < n; ++dx) {
                                for (int dy = 0; dy < m; ++dy) {
                                    if (block[dx][dy] == '.') continue;
                                    if (board[x + dx][y + dy] != '.') puttable = false;
                                }
                            }

                            if (!puttable) continue;

                            for (int dx = 0; dx < n; ++dx) {
                                for (int dy = 0; dy < m; ++dy) {
                                    if (block[dx][dy] == '.') continue;
                                    board[x + dx][y + dy] = 'A' + idx;
                                }
                            }

                            bool result = dfs(idx + 1);

                            for (int dx = 0; dx < n; ++dx) {
                                for (int dy = 0; dy < m; ++dy) {
                                    if (block[dx][dy] == '.') continue;
                                    board[x + dx][y + dy] = '.';
                                }
                            }

                            if (result) return true;
                        }
                    }
                    return false;
                }
            };

        std::cout << (dfs(0) ? "Yes" : "No") << std::endl;
    }
    return 0;
}
accuracy: 1
time_ms: 500
memory_kb: 3220
final_rank: 17