UVA1602

题目描述：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=51164

/*
solution：
    本题利用回溯法解决。本题实际上是要搜索n连通块不同形态的个数（平移，翻转，旋转后相同的算作一种形态），因此能够有效的判断n连通块是否重复是关键。

    那么如何判断是否重复呢？我们一步步的分析。由于可能要涉及对一个对象的旋转，平移，翻转操作，因此我们有必要定义好相应的结构体去支持这些操作的完成。
    首先不难发现，每个单元格应当作为一个结构体出现，用(x,y)即可完整的描述一个具体的单元格，不妨定义为Cell结构体。对于一个连通块，我们实际上关心的
    是他的外部形态，并不关心每个格子的位置，因此可以将set<Cell>当做一个结构体，定义为Polyomino，表示一系列Cell拼成的连通块。

    接下来考虑连通块应当具备什么样的操作？对于平移操作，我们可以定义一个normalize函数，找出x,y分别的最小值minX,minY，那么它可以视为一个平移矢量
    (minX,minY)，将连通块的每个单元格都减去该矢量，即实现了标准化。对于旋转操作，我们可以定义一个rotate函数，表示将整个连通块围绕坐标原点顺时针旋
    转90度。如何实现呢？其实很简单，只需要将每个格子都顺时针旋转90度即可。相应的几何变换为(x,y)->(y,-x)。对于翻转操作，由于既可以沿x轴翻转，也可以
    沿y轴翻转，但实际上沿x轴翻转后再绕坐标原点顺时针旋转180度即可得到沿y轴翻转的图案。因此这里我们定义一个flip函数，表示将一个连通块沿x轴翻转。相应
    的几何变换为(x,y)->(x,-y)。

    有了上述的三种操作以后，判断是否重复就变得非常简单了。首先将当前的连通块平移到坐标原点，每次都顺时针旋转90度，检查是否和当前的n连通块集合中出现的
    有重复。如果均没有，将该连通块沿x轴翻转后，再依次顺时针旋转90度判断，如果均没有，就表示这是一种新的形态，加入到n连通块所在的集合中即可。

    解决了判重的问题，接下来考虑如何枚举所有的n连通块。一个n连通块，当n>1时，一定是在n-1连通块的基础上生成的，即以每个n-1连通块为基础，以某一个n-1
    连通块的某个单元格开始，向上下左右4个方向扩展。如果可以扩展，且不出现重复，就找到了一个n连通块，加入到集合中来。最终完成n连通块的枚举。

    为了避免每次输入都要进行一次枚举，我们可以事先对所有的n连通块个数打表，题目中w,h的范围都比较小，可以用ans
    [w][h]来表示在w*h网格内的n连通块的个数。打表后直接输出即可。

    注意：在rotate函数和flip函数中，一定要先进行旋转或者翻转操作，再标准化，如果顺序弄反了会改变其中平移矢量的角度，使得后续判断出错。

note:
    注意此题不能用一般的回朔法枚举，原因是下一枚摆放的连通块要依赖于上一枚拜访的块从4个方向探测而得到。现在举个题目中就给出的反例：5 2 4
    用n皇后框架写的回朔法会得到4（答案是5），因为下面这种情况用n皇后的框架是无法枚举到（*代表空格，1代表块）：

    1*
    11
    1*
    1*
    1*

    可以从代码看起，按n皇后框架思路，从00位置开始探测，一直到最左上角的1,然后开始摆放最后一个块，首先上下左三个方向均不合适，所以向右摆放，因为
    这时的联通体已经枚举过了，题目中的第二个联通体，所以根据n皇后的回朔，撤销最左上角的1,重新摆放第4个块。如下图：

    **
    11
    1*
    1*
    1*

    所以无论如何也不能得到第一副图。
    解决方法是根据前面的n-1个连块来求最后一个，具体做法见代码中make_Ans_List()函数

date:   2016/5/14
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>

using namespace std;
int n, w, h, ans[11][11][11], board[10][10];

struct Cell {
    int x, y;

    Cell(int x = 0, int y = 0) : x(x), y(y) {}

    bool operator < (const Cell& rhs) const {
        if(x != rhs.x)  return x < rhs.x;
        else            return y < rhs.y;
    }
};
typedef set<Cell> polyomino;
set<polyomino> sp[11];  //sp[i]代表i个连块构成的连通体的集合

const int dir_x[] = {-1,1,0,0};
const int dir_y[] = {0,0,-1,1};

inline polyomino normalize(const polyomino& p) {    //标准化操作
    int minx = p.begin()->x, miny = p.begin()->y;
    for(polyomino :: const_iterator it = p.begin(); it != p.end(); it++) {
        minx = min(minx, it->x);
        miny = min(miny, it->y);
    }

    polyomino tmp;
    for(polyomino :: const_iterator it = p.begin(); it != p.end(); it++) {
        int x = it->x, y = it->y;
        tmp.insert(Cell(x - minx, y - miny));
    }
    return tmp;
}

inline polyomino rotation(const polyomino& p) { //以左下角为坐标系原点，将其顺时针翻转90度
    polyomino tmp;
    for(polyomino :: const_iterator it = p.begin(); it != p.end(); it++) {
        int x = it->x, y = it->y;
        tmp.insert(Cell(y, -x));
    }

    return normalize(tmp);
}

inline polyomino flip_x(const polyomino& p) {   //沿着x轴翻转
    polyomino tmp;
    for(polyomino :: const_iterator it = p.begin(); it != p.end(); it++) {
        int x = it->x, y = it->y;
        tmp.insert(Cell(x, -y));
    }

    return normalize(tmp);
}

void set_poly(const polyomino& p, const Cell& c) {
    polyomino tmp = p;
    tmp.insert(c);
    tmp = normalize(tmp);   //标准化

    int n = tmp.size();
    for(int i = 0; i < 4; i++) {
        if(sp[n].count(tmp))    return;
        tmp = rotation(tmp);
    }

    tmp = flip_x(tmp);
    for(int i = 0; i < 4; i++) {
        if(sp[n].count(tmp))    return;
        tmp = rotation(tmp);
    }

    sp[n].insert(tmp);
}

void make_Ans_List() {
    polyomino cur;
    cur.insert(Cell(0, 0));
    sp[1].insert(cur);  //只有一个块的时候

    for(int n = 1; n <= 10; n++)
    for(set<polyomino> :: iterator it = sp[n - 1].begin(); it != sp[n - 1].end(); it++) {
        for(polyomino :: const_iterator cit = (*it).begin(); cit != (*it).end(); cit++) {
            for(int dir = 0; dir < 4; dir++) {
                Cell newc(cit->x + dir_x[dir], cit->y + dir_y[dir]);
                if((it->count(newc)) == 0)  set_poly(*it, newc);
            }
        }
    }

    for(int n = 1; n <= 10; n++)
    for(int w = 1; w <= 10; w++)
    for(int h = 1; h <= 10; h++) {
        int cnt = 0;
        for(set<polyomino> :: iterator it = sp[n].begin(); it != sp[n].end(); it++) {
            int maxx = 0, maxy = 0;
            for(polyomino :: const_iterator c = (*it).begin(); c != (*it).end(); c++) {
                maxx = max(maxx, c->x);
                maxy = max(maxy, c->y);
            }
            if(min(maxx, maxy) < min(w, h) && max(maxx, maxy) < max(w, h))  cnt++;
        }
        ans[n][w][h] = cnt;
    }
}

int main()
{
    //freopen("input.txt", "r", stdin);
    make_Ans_List();
    while(~scanf("%d%d%d", &n, &w, &h)) {
        if(n > w * h)   printf("0\n");
        else {
            printf("%d\n", ans[n][w][h]);
        }
    }

    return 0;
}