uva1602 无方向位置的姿势判重

1. 存储一个姿势，不针对它的方向和位置。涉及三个动作：翻转，移动，旋转。
2. 利用标准化使位置固定到一个相对位置上。
3. 利用三个动作判重。
4. 利用集合来无重复的保存解，
5. 判断解的范围进行取舍。

题目链接：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=51164
题解来自LinVan的博客，链接在我博客的相关链接中。：
本题利用回溯法解决。本题实际上是要搜索n连通块不同形态的个数（平移，翻转，旋转后相同的算作一种形态），因此能够有效的判断n连通块是否重复是关键。
那么如何判断是否重复呢？我们一步步的分析。由于可能要涉及对一个对象的旋转，平移，翻转操作，因此我们有必要定义好相应的结构体去支持这些操作的完成。
首先不难发现，每个单元格应当作为一个结构体出现，用(x,y)即可完整的描述一个具体的单元格，不妨定义为Cell结构体。对于一个连通块，我们实际上关心的
是他的外部形态，并不关心每个格子的位置，因此可以将set当做一个结构体，定义为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函数中，一定要先进行旋转或者翻转操作，再标准化，如果顺序弄反了会改变其中平移矢量的角度，使得后续判断出错。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;

struct Cell {//定义结构体，保存元素
  int x, y;
  Cell(int x=0, int y=0):x(x),y(y) {};
  bool operator < (const Cell& rhs) const {
    return x < rhs.x || (x == rhs.x && y < rhs.y);
  }
};

typedef set<Cell> Polyomino;//保存一个解，利用set保存不重复

#define FOR_CELL(c, p) for(Polyomino::const_iterator c = (p).begin(); c != (p).end(); ++c)

inline Polyomino normalize(const Polyomino &p) {//标准化，放正这个元素
  int minX = p.begin()->x, minY = p.begin()->y;
  FOR_CELL(c, p) {
    minX = min(minX, c->x);
    minY = min(minY, c->y);
  }
  Polyomino p2;    
  FOR_CELL(c, p)
    p2.insert(Cell(c->x - minX, c->y - minY));
  return p2;
}

inline Polyomino rotate(const Polyomino &p) {//旋转
  Polyomino p2;
  FOR_CELL(c, p)
    p2.insert(Cell(c->y, -c->x));
  return normalize(p2);
}

inline Polyomino flip(const Polyomino &p) {//翻转
  Polyomino p2;
  FOR_CELL(c, p)
    p2.insert(Cell(c->x, -c->y));
  return normalize(p2);//最后要标准化
}

const int dx[] = {-1,1,0,0};//保存状态
const int dy[] = {0,0,-1,1};
const int maxn = 10;

set<Polyomino> poly[maxn+1];
int ans[maxn+1][maxn+1][maxn+1];

// add a cell to p0 and check whether it's new. If so, add to the polyonimo set
void check_polyomino(const Polyomino& p0, const Cell& c) {//检查是否可以添加
  Polyomino p = p0;
  p.insert(c);
  p = normalize(p);

  int n = p.size();
  for(int i = 0; i < 4; i++) {
    if(poly[n].count(p) != 0) return;
    p = rotate(p);
  }      
  p = flip(p);
  for(int i = 0; i < 4; i++) {
    if(poly[n].count(p) != 0) return;
    p = rotate(p);
  }
  poly[n].insert(p);
}

void generate() {
  Polyomino s;
  s.insert(Cell(0, 0));
  poly[1].insert(s);

  // generate
  for(int n = 2; n <= maxn; n++) {
    for(set<Polyomino>::iterator p = poly[n-1].begin(); p != poly[n-1].end(); ++p)
      FOR_CELL(c, *p)
        for(int dir = 0; dir < 4; dir++) {//从头到脚进行遍历
          Cell newc(c->x + dx[dir], c->y + dy[dir]);
          if(p->count(newc) == 0) check_polyomino(*p, newc);
        }
  }

  // precompute answers
  for(int n = 1; n <= maxn; n++)
    for(int w = 1; w <= maxn; w++)
      for(int h = 1; h <= maxn; h++) {
        int cnt = 0;
        for(set<Polyomino>::iterator p = poly[n].begin(); p != poly[n].end(); ++p) {
          int maxX = 0, maxY = 0;
          FOR_CELL(c, *p) {
            maxX = max(maxX, c->x);
            maxY = max(maxY, c->y);
          }
          if(min(maxX, maxY) < min(h, w) && max(maxX, maxY) < max(h, w))//最小值和最大值都在边界当中
            ++cnt;//符合要求的解
        }
        ans[n][w][h] = cnt;
      }
}

int main() {
  generate();

  int n, w, h;
  while(scanf("%d%d%d", &n, &w, &h) == 3) {
    printf("%d\n", ans[n][w][h]);
  }
  return 0;
}