HDU 4331 - Image Recognition

 

题目地址： http://acm.hdu.edu.cn/showproblem.php?pid=4331

 

方法一是由我写的求实体矩阵个数的DP + 怪叔叔的YY暴力法（结果证明貌似时间复杂度不是很高）。

 

方法二是参照CJ牛讲的，用优先队列维护，用树状数组求个数。

 

============================================================================================

 

方法一：

 

DP。。。

 

用 f[ ][ ] 保存所有实心正方形的边。

用 lft[ ][ ] 保存所有点向左延伸的都为1的边的长度。

用 up[ ][ ] 保存所有点向上延伸的都为1的边的长度。

 

每当得到一个实心正方形时，就相当于多找到了 f[ ][ ] 个边上点都是1的正方形。

 

然后继续向左边与上边延伸，寻找边上点都为1的正方形。

 

按理说，这样算的时间复杂度应该很高。。。O( n^2 * n/2 )

 

但是我手出了一组数据，边长为1000的正方形矩阵，奇数行和奇数列上的点全都为1。。。

 

这样的“极限”数据。。。竟然只跑了2秒。。。

 

 

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
__int64 sum;
const int maxn=1005;
short mp[maxn][maxn];
short f[maxn][maxn],up[maxn][maxn],lft[maxn][maxn];
int main(){
	int t,tt;
	int n,i,j,tmp,k;
	scanf("%d",&t);
	for(tt=1;tt<=t;tt++){
		scanf("%d",&n);
		for(i=1;i<=n;i++){
			for(j=1;j<=n;j++){    
				scanf("%d",&mp[i][j]);
				if(mp[i][j]) up[i][j]=1,lft[i][j]=1;
				else up[i][j]=0,lft[i][j]=0;
				if(mp[i-1][j]) up[i][j]+=up[i-1][j];
				if(mp[i][j-1]) lft[i][j]+=lft[i][j-1]; 
			}
		}
		sum=0;
		for(i=1;i<=n;i++){
			for(j=1;j<=n;j++){
				if(mp[i][j]){
					f[i][j]=1;
					if(mp[i-1][j]==1 && mp[i][j-1]==1){
						f[i][j]=min(f[i-1][j],f[i][j-1]);
						if(mp[i-f[i][j]][j-f[i][j]]==1) f[i][j]++;    
					}
					sum+=f[i][j];
					for(k=f[i][j];i-k>=1&&j-k>=1;k++){                        
						if(mp[i-k][j]&&mp[i][j-k]){
							if(lft[i-k][j]>=k+1&&up[i][j-k]>=k+1)
							sum++;
						}
						else break;
					}
				}
				else f[i][j]=0;
			}
		}
		printf("Case %d: %I64d\n",tt,sum);
	}
	return 0;
}

 =============================================================================================

方法二：

 

先求每一个坐标，向上下左右四个方向，连续的1的延伸长度。

 

然后在对角线上，使用树状数组统计正方形个数，并用优先队列维护，删除已经达不到当前位置的点。

 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>

using namespace std;

const int maxn=1011;

int n;
short p[maxn][maxn];
short lef[maxn][maxn],rit[maxn][maxn],up[maxn][maxn],down[maxn][maxn];
int tree[maxn];

void init_(){
	int i,j;
	for(i=0;i<n;i++)
		for(j=0;j<n;j++){
			lef[i][j]=(p[i][j]==0||j==0)?p[i][j]:1+lef[i][j-1];
			up[i][j]=(p[i][j]==0||i==0)?p[i][j]:1+up[i-1][j];
		}
	for(i=n-1;i>=0;i--)
		for(j=n-1;j>=0;j--){
			rit[i][j]=(p[i][j]==0 ||j==n-1)?p[i][j]:1+rit[i][j+1];
			down[i][j]=(p[i][j]==0||i==n-1)?p[i][j]:1+down[i+1][j];
		}	
}

struct Point{
	int x,len;
	Point(){}
	Point(int a,int b){x=a,len=b;}
	bool friend operator<(Point p,Point q){
		return p.x+p.len>q.x+q.len;
	}
};
priority_queue<Point>que;

void add(int v,int val){
	while(v<=1000){
		tree[v]+=val;
		v+=v&-v;
	}
}
int query(int v){
	int sum=0;
	while(v>=1){
		sum+=tree[v];
		v-=v&-v; 
	}
	return sum;
}

int deal(){
	int x,y,i,j,sum=0;
	Point tmp;
	for(i=n-1;i>-n;i--){
		while(!que.empty())que.pop();
		memset(tree,0,sizeof(tree));
		for(i>0?(x=i,y=0):(x=0,y=-i);x<n&&y<n;x++,y++){
			if(p[x][y]){
				que.push(Point(x,min(down[x][y],rit[x][y])));
//	cout<<"("<<x<<","<<y<<"): "<<endl;
//	cout<<" --down: "<<down[x][y]<<" --right: "<<rit[x][y]<<" --up: "<<up[x][y]<<" --left: "<<lef[x][y]<<endl;
				add(x+1,1);
			}
			while(!que.empty()){
				tmp=que.top();
				if(tmp.x+tmp.len>=x) break;
				add(tmp.x+1,-1);
				que.pop();
			}
			sum+=query(x+1)-query(x-min(up[x][y],lef[x][y])+1);
		} 
	} 
	return sum;
}

int main(){
	int t,tt,i,j,res;
	for(scanf("%d",&t),tt=1;tt<=t;tt++){
		scanf("%d",&n);
		for(i=0;i<n;i++)
			for(j=0;j<n;j++)
				scanf("%d",&p[i][j]);
		init_();
		res=deal();
		printf("Case %d: %d\n",tt,res);
	}
	return 0;
}