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 つ目の盤面のようなブロックの配置の仕方もありえることに注意してください。すなわち、入力で与えられる盤面はテトロミノを組み合わせて作られる盤面とは限りません。

Solution in Rust (judge verdict: Accepted)

//---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std;
    use std::io::Read;
    use std::str::FromStr;
    use std::str::SplitWhitespace;
    pub struct Scanner<'a> {
        it: SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            match self.it.next().unwrap().parse::<T>() {
                Ok(v) => v,
                _ => panic!("Scanner error"),
            }
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.next::<String>().chars().collect()
        }
    }
    pub fn read_string() -> String {
        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    }
}
//---------- end scannner ----------

use std::io::Write;

fn main() {
    let sc = scanner::read_string();
    let sc = scanner::Scanner::new(&sc);
    let out = std::io::stdout();
    let out = std::io::BufWriter::new(out.lock());
    run(sc, out);
}

fn run(mut sc: scanner::Scanner, mut out: std::io::BufWriter<std::io::StdoutLock>) {
    let mut mino = vec![];
    for _ in 0..4 {
        let h: usize = sc.next();
        let w: usize = sc.next();
        let mut b = 0u64;
        for i in 0..h {
            let s = sc.next_chars();
            for j in 0..w {
                if s[j] == '#' {
                    b |= 1u64 << (i * 10 + j) as u64;
                }
            }
        }
        mino.push((h, w, b));
    }
    let mut board = vec![];
    for i in 0..4 {
        let mut a = vec![];
        for j in 0..4 {
            if i == j {
                continue;
            }
            a.push(mino[j]);
        }
        for i in 0..40 {
            let (h, w, b) = a[0];
            let (x, y) = (i / 10, i % 10);
            if x + h > 4 || y + w > 10 {
                continue;
            }
            let bit = b << i;
            for j in 0..40 {
                let (h, w, b) = a[1];
                let (x, y) = (j / 10, j % 10);
                if x + h > 4 || y + w > 10 {
                    continue;
                }
                if (bit >> j) & b > 0 {
                    continue;
                }
                let bit = bit | (b << j);
                for k in 0..40 {
                    let (h, w, b) = a[2];
                    let (x, y) = (k / 10, k % 10);
                    if x + h > 4 || y + w > 10 {
                        continue;
                    }
                    if (bit >> k) & b > 0 {
                        continue;
                    }
                    let bit = bit | (b << k);
                    board.push(bit);
                }
            }
        }
    }
    board.sort();
    board.dedup();
    let n: usize = sc.next();
    for _ in 0..n {
        let mut b = 0;
        for i in 0..4 {
            let s = sc.next_chars();
            for j in 0..10 {
                if s[j] == '.' {
                    b |= 1u64 << (10 * i + j);
                }
            }
        }
        let ans = if let Ok(_) = board.binary_search(&b) {
            "Yes"
        } else {
            "No"
        };
        writeln!(out, "{}", ans).unwrap();
    }
}