盖游戏板问题

题目：
有一个H*W大小的游戏板，由黑白两种格子组成。现要用3个单位格子的L状板块把白色格子全部覆盖掉。板块可以自由旋转，但不能重叠覆盖黑色格子，或超出游戏版。
计算对给定游戏板有几种覆盖方法。

解决思路：
此题也属于计算组合个数的问题。因此，通过穷举搜索法计算出能够覆盖游戏板的所有可能的组合来解决此问题。首先要处理给定游戏板的白色格子不是3的倍数的情况，此时不可能存在答案，所以要单独处理。之后把白色格子除以3，得到盖上白色格子所需的L型板块数量M。现在可以把整个求解个过程分解为N个小的操作，每个操作视为是放置1个板块。利用递归函数，首先在给定的游戏板中放置1块板块，剩余的将使用递归调用的方式覆盖。

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdlib.h>
#include<time.h>
#include<string>
#include<math.h>
#include<map>
#include<queue>
#include<stack>
#define INF 0x3f3f3f3f
#define ul unsigned long long
#define ll long long
#define For(i,a,b) for(int i=a;i<b;i++)
#define sf(a)  scanf("%d",&a)
#define sfs(a)  scanf("%s",a)
#define sff(a,b)  scanf("%d%d",&a,&b)
#define pf(a) printf("%d\n",a)
#define mem(a,b) memset(a,b,sizeof(a))
#define lowbit(a) ( (a)&-(a))
const ll maxn = 2e5 + 10;
const ll N = 1e6 + 10;
const ll mod = 1e9+7;
int dx[5] = { 1,-1,0,0,0 }, dy[5] = { 0,0,1,-1,0 };
int fx[8][2]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
using namespace std;

//对当前格子的四种覆盖方法
//构成板块的3个格子的相对位置
const int coverType[4][3][2]{
  {{0,0},{1,0},[0,1]},  //
  {{0,0},{0,1},[1,1]},  
  {{0,0},{1,0},[1,1]},  
  {{0,0},{1,0},[1,-1]},  
};

//把board 的格子(y,x)用第type种方法进行覆盖或删除已经覆盖的板块
//delta = 1 表示板块覆盖，delta = -1 表示删除已覆盖的板块
//如果不能正常覆盖，(如越界，重叠，覆盖了黑色的格子式)返回false
bool set(vector<vector<int>>&board,int y ,int x,int type,int delta){
    bool ok = true;
    for(int i=0;i<3;++i){
        const int ny = y+coverType[type][i][10];
        const int nx = x+coverType[type][i][1];
        if(ny<0||ny>=board.size()||nx<0||nx>=board[0].size())
            ok = false;
        else if((board[ny][nx]+=delta)>1)
            ok = false;
    }
    return ok;
}

//返回覆盖borad 种保存着的所有空格的方法总数。
//board[i][j] = 1 表示已经覆盖的格子或者黑色格子
//board[i][j] = 0 表示未被覆盖的白色格子
int cover(vector<vector<int>>&board){
    int y = -1,x = -1;
    // 在剩余没有被覆盖的白色格子中，寻找最左上角的格子
    for(int i=0;i<board.size();++i){
        for(int j =0;j<board[i].size();++j){
            if(board[i][j] == 0){
                y = i,x = j;
                break;
            }
        }
        if(y!=-1)break;
    }
    //初始部分：已覆盖所有的白色格子，则返回1
    if(y == -1)return 1;
    int ret = 0;
    for(int type = 0;type<4;++type){
        // 如果能以type 的形式覆盖，就进行递归调用
        if(set(board,y,x,type,1))
        ret += cover(board);
        // 删除已经覆盖的板块
        set(board,y,x,typr,-1);
    }
    return ret;
}

int main(int argc, const char * argv[]) {
    int c;
    char temp;
//    int t;
    cin>>c;
    int H,W;
    vector<vector<int>> board;
    vector<int> v;
    while (c--) {
        scanf("%d %d",&H,&W);
        board.clear();
        for(int i=0;i<H;i++){
            v.clear();
            for (int j=0; j<W; j++) {
                cin>>temp;
                if(temp=='#')v.push_back(1);
                else if(temp=='.')v.push_back(0);
            }
            
            board.push_back(v);
        }
        int ret=0;
        ret=cover(board);
        cout<<ret<<endl;
        
    }
    return 0;
}