例题7-14 网格动物 UVa1602

1.题目描述：点击打开链接

2.解题思路：本题利用回溯法解决。本题实际上是要搜索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函数中，一定要先进行旋转或者翻转操作，再标准化，如果顺序弄反了会改变其中平移矢量的角度，使得后续判断出错。

3.代码：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cctype>
#include<functional>
using namespace std;

#define me(s) memset(s,0,sizeof(s))
#define pb push_back
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair <int, int> P;

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);//由于要使用set，必须对单元格定义大小关系
    }
};

typedef set<Cell>Polyomino;//定义连通块

#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;//找到x,y的最小值，然后把每个单元格都分别减去minX,minY，得到标准化后的单元格
    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)//旋转操作，对一个连通块顺时针旋转90度，并标准化
{
    Polyomino p2;
    FOR_CELL(c,p)
    p2.insert(Cell(c->y,-c->x));
    return normalize(p2);               //注意：此处一定要先旋转，再标准化！
}

inline Polyomino flip(const Polyomino&p)//翻转操作，对一个连通块沿x轴翻转，并标准化
{
    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 N=10;

set<Polyomino>poly[N+1];//连通块集合，poly[i]表示所有的i连通块构成的集合
int ans[N+1][N+1][N+1];//打表，ans
[w][h]表示w*h网格中的n连通块的个数

void check_polyomino(const Polyomino&p0,const Cell&c)//判断重复性，如果p0+c构成的连通块不重复，则加入到集合中
{
    Polyomino p=p0;
    p.insert(c);
    p=normalize(p);//先进行标准化

    int n=p.size();
    for(int i=0;i<4;i++)//每次旋转90度，看能否在当前的n连通块集合里找到
    {
        if(poly
.count(p))return;
        p=rotate(p);
    }
    p=flip(p);//翻转
    for(int i=0;i<4;i++)//再每次旋转90度，看能否找到
    {
        if(poly
.count(p))return;
        p=rotate(p);
    }
    poly
.insert(p);//说明是一个新的形态，加入集合
}

void Generate()//生成所有的n连通块，并打表
{
    Polyomino s;
    s.insert(Cell(0,0));
    poly[1].insert(s);

    for(int n=2;n<=N;n++)//枚举每个n连通块集合
        for(set<Polyomino>::iterator p=poly[n-1].begin();p!=poly[n-1].end();p++)//枚举每个n连通块
        FOR_CELL(c,*p)//枚举一个n连通块的每个单元格
        for(int dir=0;dir<4;dir++)//枚举4个方向，看能否扩展
    {
        Cell newc(c->x+dx[dir],c->y+dy[dir]);
        if(p->count(newc)==0)check_polyomino(*p,newc);
    }

    for(int n=1;n<=N;n++)
        for(int w=1;w<=N;w++)
        for(int h=1;h<=N;h++)//打表
    {
        int cnt=0;
        for(set<Polyomino>::iterator p=poly
.begin();p!=poly
.end();p++)
        {
            int maxX=0,maxY=0;
            FOR_CELL(c,*p)    //寻找当前的连通块的最大的x，y
            {
                maxX=max(maxX,c->x);
                maxY=max(maxY,c->y);
            }
            if(min(maxX,maxY)<min(h,w)&&max(maxX,maxY)<max(h,w))++cnt;//能够放入w*h网格内的条件
        }
        ans
[w][h]=cnt;
    }
}

int main()
{
    Generate();

    int n,w,h;
    while(~scanf("%d%d%d",&n,&w,&h))
        printf("%d\n",ans
[w][h]);
}