搜索 【uva1602】Lattice Animals （练习题7-14 网格动物）

7-14 网格动物（Lattice Animals uva 1602）
(animals.cpp,Time limit: 3.000 seconds)

题目描述：
给你一个w*h的网格，你可以用含有n个方块块去填充它，要求这n个方块连同，想知道一共有多少中填充方法（连通就不用解释了……吧）。
注：如果一个图形能通过另一个图形平移或者旋转得到，那么认为这两个图形是相同的。
(以上是我自己理解的，如果有不清晰的地方……可以看英文原版）

举例子：
第一行：用5个方块的连通块填充2*4的方格，有5种填法。
第二行：用8个方块的连通块填充3*3的方格，有3种填法。

输入格式：
多组数据。
每行3个正整数n，w，h（1<=n<=10,1<=w,h<=n）

输出格式:
对于每组数据输出一行一个整数，代表有多少种填充方式。

样例输入：

5 1 4
5 2 4
5 3 4
5 5 5
8 3 3

样例输出：

0
5
11
12
3

题目分析：（搜索+set判重）

这种构造图形的题只能搜索了，重点是怎么搜，搜的时候要注意什么。
比较容易想到分层搜索，按照方块的数量来分层。
如果要是bfs搜到第10层就不要扩展新的状态。
如果dfs就迭代加深，搜到10层就回溯，我用的是深搜。

这道题其实没有什么技巧可言，在第一层的时候只有一种情况，就是一个方块，我们把这个图形储存下来，用它来扩展下一层的图形。
然后再用第二层得到的新图形来扩展第三层的图形，以此类推。

由于旋转平移和翻转之后如果图形相同答案不重复计算，所以需要判重，本来是想用hash的，但是本蒟蒻想不到一个把图形转成数字的好方法，所以就用set暴力判重了。

一个图形通过旋转和翻转会得到8种图案，我们可以用坐标的形式存储这个图形，并通过四次旋转90度，并且每次旋转之后翻转的方式得到8种图案。

因为平移也会影响坐标，所以我们统一把图案移动到第一象限，且使这个图案离坐标轴尽可能近，这样每种图案就只有八种表示方式。我们只把其中一个扔到set里，然后每次得到一个新的图案时，就用它的八种形式在set中跑一边判重，只要有一个在set出现过就可以减掉了。

这样我们保证所有的有用的图形都会扩展其它图形一次，而其实图形的总数只有6473，一个图形最多扩展出其它的图形也只有十几个，那么时间复杂度的级别在1e6左右，即使时限是1秒也跑出来了，都不用剪枝（也没有什么可以减的了）。

但是这道题是多组数据，如果你每次都搜一遍，把时间复杂度乘以300，那就很玄学了，所以你可以先把所有的数据都跑出来，存到一个数组里，最后一起输出结果。

代码如下（代码解释在代码后）：

#include<cstdio>
#include<algorithm>
#include<set>
#include<iostream>
using namespace std;
const int INF=1000;
inline int Min(int x,int y) {return x<y?x:y;}
inline int Max(int x,int y) {return x>y?x:y;}

struct point{
    int x,y;
    bool operator == (const point c) const {return x==c.x && y==c.y;}
    bool operator <  (const point c) const {return x<c.x || (x==c.x && y<c.y);}
    point operator + (const point c)
    {
        static point ans;
        ans.x=x+c.x;
        ans.y=y+c.y;
        return ans;
    }
};
const point trans[4]={{0,1},{0,-1},{1,0},{-1,0}};

struct graph{
    point spot[11];
    int sz;

    bool operator < (const graph c) const
    {
        if(sz!=c.sz) return true;
        for(int i=0;i<sz;i++)
        {
            if(spot[i]<c.spot[i]) return true;
            if(c.spot[i]<spot[i]) return false;
        }
        return false;
    }

    void translation()
    {
        sort(spot,spot+sz);
        int xmin=INF,ymin=INF;
        for(int i=0;i<sz;i++)
        {
            xmin=Min(xmin,spot[i].x);
            ymin=Min(ymin,spot[i].y);
        }
        xmin=1-xmin,ymin=1-ymin;
        for(int i=0;i<sz;i++)
        {
            spot[i].x+=xmin;
            spot[i].y+=ymin;
        }
        return;
    }

    void turn()
    {
        for(int i=0;i<sz;i++)
        {
            swap(spot[i].x,spot[i].y);
            spot[i].x=-spot[i].x;
        }
        translation();
        return;
    }

    friend graph flip(graph c)
    {
        for(int i=0;i<c.sz;i++) c.spot[i].x=-c.spot[i].x;
        c.translation();
        return c;
    }

    void calculate(int &wide,int &height)
    {
        int minx=INF,maxx=-INF,miny=INF,maxy=-INF;
        for(int i=0;i<sz;i++)
        {
            minx=Min(minx,spot[i].x);
            maxx=Max(maxx,spot[i].x);
            miny=Min(miny,spot[i].y);
            maxy=Max(maxy,spot[i].y);
        }
        wide=maxx-minx+1;
        height=maxy-miny+1;
    }
}variable;

set<graph> V[11];
int ans[11][11][11];
int n,w,h;

void dfs(int c)
{
    const graph cur=variable;
    for(int i=0;i<c;i++)
        for(int j=0;j<4;j++)
    {
        variable=cur;
        point temp=variable.spot[i]+trans[j];

        bool judge=true;
        for(int k=0;k<variable.sz;k++)
            if(temp==variable.spot[k]) { judge=false; break; }
        if(!judge) continue;

        variable.spot[variable.sz++]=temp;
        for(int k=1;k<=4;k++)
        {
            variable.turn();
            if(V[c+1].find(variable)!=V[c+1].end()) { judge=false;break;}
            graph flipping = flip(variable);
            if(V[c+1].find(flipping)!=V[c+1].end()) { judge=false;break;}
        }
        if(!judge) continue;

        int wide,height;
        variable.calculate(wide,height);
        if(wide<height) swap(wide,height);
        ans[c+1][wide][height]++;
        V[c+1].insert(variable);
        if(c==9) continue;
        dfs(c+1);
    }
    return;
}

void get_ans()
{
    variable.sz=1;
    variable.spot[0].x=1;
    variable.spot[0].y=1;
    ans[1][1][1]++;
    V[1].insert(variable);
    dfs(1);

    for(int i=1;i<=10;i++)
        for(int j=1;j<=10;j++)
            for(int k=1;k<=10;k++)
                ans[i][j][k]+=ans[i][j-1][k]+ans[i][j][k-1]-ans[i][j-1][k-1];
    for(int i=1;i<=10;i++)
        for(int j=1;j<=10;j++)
            for(int k=1;k<j;k++)
              ans[i][k][j]=ans[i][j][k];
}

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

代码解释：
此下文段送给我的学弟学妹们（自认为代码可读性还可以，但是还是想写一写）。

结构体point代表点，x，y代表横纵坐标。

结构体graph代表图案，里面存储10个点代表具体的图案，sz代表这个图案的大小（即该图案由多少个方块构成）
因为graph要判重，所以要重定义 < 运算符。
translation是把所有的点排序并把整个图形平移到第一象限处。
turn是把这个图形逆时针旋转90度。
flip是把该图案翻转并返回当前图案。
calculate是计算当前图案的宽和高。

dfs：
枚举当前图案的每一个点并且枚举向哪个方向扩展。
第一次要判断是否这个点已经在这个图形中出现过，
第二次要判断增加这个点之后的图形是否已经出现过。
如果是可行解，就统计答案，并搜索下一层。

dfs之后的ans[i][j][k]表示表示用i个方块恰好填充j*k的网格的方案数。
我们需要把答案统计起来。
之后的for循环就是做这个用的（具体原理就不细说了，如果不明白的话再开一个数组暴力统计也可以，毕竟n<=10，n^5都能过）。