UVA 1062 Lattice Animals

P3870网格动物

时间限制 : - MS   空间限制 : 165536 KB 评测说明 : 3s

问题描述

网格动物是一种在网格中的联通块，由n个方块构成的联通块称为n连块。平移、旋转、翻转之后相同的算作同一种。例如，2*4里面的5连块有5种（第一行），3*3里的8连块有3种（第二行）。

输入n,w,h，请问w*h的网格里有多少种n连块？

输入格式

输入包含多组数据，每组数据仅一行，三个整数n,w,h。

输出格式

每行输出一个整数，表示N连块的个数

样例输入

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

样例输出

0
5
11
12
3

提示

1<=n<=10
1<=w,h<=n

数据组数<=300

看数据范围就知道是搜索题了……，虽然组数比较多我们可以先算出数组ans[n][w][h]然后直接输出就完了

我们就从(0,0)号点开始往上下左右四个方向搜索，如果对于一个搜到的连通块，在此之前已经搜到了一个连通块可以通过翻转，旋转，翻转后旋转等等操作得到这个连通块，就说明这个连通块已经出现过了，不计入答案

那么我们判断一个连通块是否出现过呢?我们可以使用如下方法:
定义一个结构体Single，表示每一个单位格子的位置坐标

再定义一个集合set<Single>，即为一个连通块所选的格子集合

再定义一个集合set<set<Single> >G[i] 即为大小为i的连通块的集合

所以判断一个连通块s是否已经出现过，只需要判断G[s.size()].count(s)即可

在搜完之后要进行一个标准化操作，即算出一个连通块集合的最小格子的坐标，然后所有其他格子的坐标都减去这个坐标，易于判断和查找

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<set>
using namespace std;
const int maxn=15,inf=0x3f3f3f3f;
inline void _read(int &x){
    char t=getchar();bool sign=true;
    while(t<'0'||t>'9')
    {if(t=='-')sign=false;t=getchar();}
    for(x=0;t>='0'&&t<='9';t=getchar())x=x*10+t-'0';
    if(!sign)x=-x;
}
struct Single{
	int x,y;
	Single(int x,int y):x(x),y(y){}
	bool operator<(const Single& h)const{
		return  x==h.x?y<h.y:x<h.x;
	} 
};
typedef set<Single> Block;
set<Block> G[maxn];
int ans[15][15][15],n,w,h,t;
int dx[4]={0,0,-1,1};
int dy[4]={-1,1,0,0};
inline Block Standarize(Block p){//标准化操作
	int minx=inf,miny=inf;
	Block temp;
	set<Single> :: iterator it;
	for(it=p.begin();it!=p.end();it++)
		minx=min(minx,it->x),miny=min(miny,it->y);
	for(it=p.begin();it!=p.end();it++)
		temp.insert(Single(it->x-minx,it->y-miny)); 
	return  temp;
}
inline Block Spin(Block p){//旋转操作
	Block temp;
	set<Single>::iterator it;
	for(it=p.begin();it!=p.end();it++)
		temp.insert(Single(it->y,-(it->x)));
	return  Standarize(temp);
}
inline Block Reverse(Block p){//翻转操作
	Block temp;
	set<Single>::iterator it;
	for(it=p.begin();it!=p.end();it++)
		temp.insert(Single(it->x,-(it->y)));
	return  Standarize(temp);
}
bool check(Block p){//判断p连通块是否已经出现过
	int i,B=p.size();
	if(G[B].count(p))return  0;
	for(i=0;i<4;i++){
		p=Spin(p);
		if(G[B].count(p))return  0;
	}
	p=Reverse(p);
	if(G[B].count(p))return  0;
	for(i=0;i<4;i++){
		p=Spin(p);
		if(G[B].count(p))return  0;
	}
	G[B].insert(p);
	return  1;
}
void dfs(Block p){
	if(p.size()==n){
		check(p);
		return  ;
	}
	set<Single> :: iterator it;
	for(it=p.begin();it!=p.end();it++){
		for(int i=0;i<4;i++){
			Single cur=Single(dx[i]+it->x,dy[i]+it->y);
			if(!p.count(cur)){
				Block temp=p;
				temp.insert(cur);
				dfs(temp);
			}
		}
	}
}
void Get_table(){
	Block s;
	s.insert(Single(0,0));
	G[1].insert(s);
	for(n=2;n<=10;n++){
		set<Block> :: iterator it;
		for(it=G[n-1].begin();it!=G[n-1].end();it++)dfs(*it);
	}
	for(n=1;n<=10;n++){
		set<Block>::iterator it;
		set<Single>::iterator i;
		for(it=G[n].begin();it!=G[n].end();it++){
			int maxx=0,maxy=0;
			for(i=it->begin();i!=it->end();i++){
				maxx=max(maxx,i->x);
				maxy=max(maxy,i->y);
			}
			if(maxx<maxy)swap(maxx,maxy);
			for(w=1;w<=10;w++)
				for(h=1;h<=10;h++)
					if(maxx<max(w,h)&&maxy<min(w,h))ans[n][w][h]++;
		}
	}
}
int main(){
	Get_table();
	while(cin>>n>>w>>h)printf("%d\n",ans[n][w][h]);
}

---

来源  spark uva1602