搜索 【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
[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都能过）。