HDU-5471 Count the Grid

题目描述

一个矩阵中可以任意填\(m\)个数。给你\(N\)个小矩阵并且告诉你此矩阵中的最大值\(v\)，求有多少种大矩阵满足所给条件。\(（\%1e9+7）\)

Input

包含\(T\)组数据.

第一行有\(h,w,m,n\)四个整数，接下来\(n\)行,每行包含5个整数\(x1，y1，x2，y2，v\).

表示每次选择左上角为\(（x1，y1）\)，右下角为\(（x2，y2）\)的矩形，该矩形的最大值\(v\)。

\(（T=55,1≤h,w,m≤1e4,1≤x1≤x2≤h,1≤y1≤y2≤w,1≤v≤m,1≤n≤10）\)

Output

每个样例输出Case #x: ans

Sample Input

2
3 3 2 2
1 1 2 2 2
2 2 3 3 1
4 4 4 4
1 1 2 3 3
2 3 4 4 2
2 1 4 3 2
1 2 3 4 4

Sample Output

Case #1: 28
Case #2: 76475

容斥神题！！

注意：下文中所提及的矩阵的交集必须仅包含当前的所有矩阵，即不能有其他不在当前状态的矩阵和交集有相交的地方。

我们很容易发现，题目所给出的\(n\)是十分小的，这就意味着我们可以利用状压来求解。

每个小矩阵之间的转移必定是和矩阵的交集或并集相关的，而并集很显然也要求出交集。

那么，我们就利用交集来求解。

一共有\(n\)个矩阵，那么就有\(2^n\)个交集，我们要求出这些交集的面积和最大值。

交集的最大值很好求出，直接\(min\)过去就行了。

而求交集的面积就要利用容斥了，

---

对于我们当前要求的集合\(s\)，其集合中矩阵相交的面积为\(tot[i]\)。

我们需要去掉其他包含其他矩阵的交集的面积。

我们可以倒着枚举集合\(s\)，同时枚举\(s\)是\(j\)的子集的集合\(j\)。

则集合\(s\)的交集就要减去集合\(j\)的交集。

drep(i,(1<<n)-1,0) {
	tot[i]=B[i].Sum();
	ret(j,i+1,1<<n)if((j|i)==j)tot[i]-=tot[j];
}

---

合并集合代码：

struct node {//由于要多次合并矩阵，我们可以直接将其封装起来，方便操作
	int xl,yl,xr,yr,val;
	inline void get(void) {
		xl=Read(),yl=Read(),xr=Read(),yr=Read(),val=Read();
	}
	inline int Sum(void) {//求矩阵面积
		return (xl>xr||yl>yr)?0:(xr-xl+1)*(yr-yl+1);
	}
	node operator+(node _)const {//求两的矩阵的相交矩阵
		node Ans;
		Ans.xl=max(xl,_.xl);
		Ans.yl=max(yl,_.yl);
		Ans.yr=min(yr,_.yr);
		Ans.xr=min(xr,_.xr);
		Ans.val=min(val,_.val);
		return Ans;
	}
} B[(1<<10)+5];
int main(){
    B[0]=(node)<%1,1,h,w,m%>;
    ret(i,1,1<<n)if((i^(i&-i)))B[i]=B[i^(i&-i)]+B[i&-i];
}

接下来，我们开始\(dp\).

定义\(dp[i][j]\)为前\(i\)种交集，已经有\(j\)状态的小矩阵满足了条件的方案数。

\(tot[i]\)为第\(i\)个交集的面积，\(val[i]\)为第\(i\)种交集的最大值，\(us[i]\)为\(i\)状态中最大值和交集最大值相同的状态。

对于当前的\(i\)，我们可以对于交集是否取到最大值进行转移，

若取到了最大值，则\(dp[i][j|us[i]]+=dp[i-1][j]*(val[i]^{tot[i]}-(val[i]-1)^{tot[i]})\)。

否则，\(dp[i][j]+=dp[i-1][j]*(val[i]-1)^{tot[i]}\)。

最后答案就是\(dp[(1<<n)-1][(1<<n)-1]\)。

注意：需要利用滚动数组来优化内存

代码如下

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define reg register
#define Raed Read
#define clr(a,b) memset(a,b,sizeof a)
#define Mod(x) (x>=mod)&&(x-=mod)
#define debug(x) cerr<<#x<<" = "<<x<<endl;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)>(b)?(b):(a))
#define rep(a,b,c) for(reg int a=(b),a##_end_=(c); a<=a##_end_; ++a)
#define ret(a,b,c) for(reg int a=(b),a##_end_=(c); a<a##_end_; ++a)
#define drep(a,b,c) for(reg int a=(b),a##_end_=(c); a>=a##_end_; --a)
#define erep(i,G,x) for(int i=(G).Head[x]; i; i=(G).Nxt[i])
#pragma GCC target("avx,avx2,sse4.2")
#pragma GCC optimize(3)
inline int Read(void) {
	int res=0,f=1;
	char c;
	while(c=getchar(),c<48||c>57)if(c=='-')f=0;
	do res=(res<<3)+(res<<1)+(c^48);
	while(c=getchar(),c>=48&&c<=57);
	return f?res:-res;
}
template<class T>inline bool Min(T &a, T const&b) {
	return a>b?a=b,1:0;
}
template<class T>inline bool Max(T &a, T const&b) {
	return a<b?a=b,1:0;
}
const int N=1e5+5,M=7e6+5,mod=1e9+7;
bool MOP1;
int n,dp[2][(1<<10)+5],tot[(1<<10)+5],us[(1<<10)+5];
struct node {
	int xl,yl,xr,yr,val;
	inline void get(void) {
		xl=Read(),yl=Read(),xr=Read(),yr=Read(),val=Read();
	}
	inline int Sum(void) {
		return (xl>xr||yl>yr)?0:(xr-xl+1)*(yr-yl+1);
	}
	node operator+(node _)const {
		node Ans;
		Ans.xl=max(xl,_.xl);
		Ans.yl=max(yl,_.yl);
		Ans.yr=min(yr,_.yr);
		Ans.xr=min(xr,_.xr);
		Ans.val=min(val,_.val);
		return Ans;
	}
} A[15],B[(1<<10)+5];
inline int Pow(int x,int y) {
	int res=1;
	while(y) {
		if(y&1)res=1ll*res*x%mod;
		x=1ll*x*x%mod,y>>=1;
	}
	return res;
}
bool MOP2;
inline void _main() {
	int T=Read(),Case=0;
	while(T--) {
		int h=Read(),w=Read(),m=Read(),n=Read();
		rep(i,1,n)A[i].get(),B[1<<(i-1)]=A[i];
		B[0]=(node)<%1,1,h,w,m%>;
		ret(i,1,1<<n)if((i^(i&-i)))B[i]=B[i^(i&-i)]+B[i&-i];
		drep(i,(1<<n)-1,0) {
			us[i]=0,tot[i]=B[i].Sum();
			ret(j,i+1,1<<n)if((j|i)==j)tot[i]-=tot[j];
			rep(j,1,n)if(A[j].val==B[i].val&&(i&(1<<(j-1))))us[i]|=1<<(j-1);
		}
		int cur=0;
		clr(dp[cur],0),dp[cur][0]=1;
		ret(i,0,1<<n) {
			cur^=1,clr(dp[cur],0);
			int res1=Pow(B[i].val-1,tot[i]);
			int res2=Pow(B[i].val,tot[i]);
			int _cur=!cur;
			ret(j,0,1<<n)if(dp[_cur][j]) {
				dp[cur][j|us[i]]+=1ll*dp[_cur][j]*((res2-res1+mod)%mod)%mod;
				dp[cur][j]+=1ll*dp[_cur][j]*res1%mod;
				Mod(dp[cur][j]),Mod(dp[cur][j|us[i]]);
			}
		}
		printf("Case #%d: %d\n",++Case,dp[cur][(1<<n)-1]);
	}
}
signed main() {
	_main();
	return 0;
}