【JZOJ4228】C

description

在远古的YL国大地上，有n个祭坛，每个祭坛上四个方向写有“艄、毜、鼛、瓯”四个大字，其实这在YL国古代分别是“东、南、西、北”的意思。
YL国每年都要举行祈福消灾的祭祀活动，这个时候，每个祭坛都要在艄毜鼛瓯四个方向中选一个方向，祭坛将向这个方向发出一道隐形的光线，如果两个祭坛发出的光线相交，或者祭坛发出的光线经过了别的祭坛，则祭祀不仅不能成功还将遭到上天的惩罚，如果这些条件都满足则祭祀将成功，YL国在接下来的一年内将不会有任何灾难，甚至只会有人出生不会有人死亡。
抽象的来说，如果我们以“艄”方向为x轴，“瓯”方向为y轴，建立笛卡尔坐标系，那么每个祭坛将会对应一个整点。每个点向上下左右四个方向之一连出一条射线，这些射线不能相交且射线不能经过除了发出点之外的其他点}。
现在他们又到了祭祀活动的时候，他们想知道，有多少种方法选择每个祭坛的方向}，使得自己的祭祀能成功？输出方案数对998244353取模后的值}。

---

analysis

• $DP$

• 首先这题很好骗分，$dfs$常数打得好可以拿$40$左右

• 对于一种合法的情况，只需知道向上的点纵坐标最小的点、向下的点纵坐标最大的点和向右的点纵坐标最大及最小的点就可以转移了

• 基于此先按照$x$排序，设$f[now][l][r][u][d]$表示到第$now$轮时，当前向右的点纵坐标最大最小的点为$l,r$，向上的点纵坐标最小的点是$u$，向下的点纵坐标最大的点是$d$，那么就可以$O(n^5)$来$DP$了

• 注意剪枝一些$0$和不合法的情况，上限完全达不到$O(n^5)$

• 对于$now$一维，滚动一下空间就可以接受了

---

code

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define maxN 60
#define mod 998244353
#define ll long long
#define reg register ll
#define fo(i,a,b) for (reg i=a;i<=b;++i)
#define fd(i,a,b) for (reg i=a;i>=b;--i)
#define O3 __attribute__((optimize("-O3")))

using namespace std;

ll f[2][maxN][maxN][maxN][maxN];
ll n,now,las,ans;

struct node
{
	ll x,y;
}a[maxN];

O3 inline ll read()
{
	ll x=0,f=1;char ch=getchar();
	while (ch<'0' || '9'<ch){if (ch=='-')f=-1;ch=getchar();}
	while ('0'<=ch && ch<='9')x=x*10+ch-'0',ch=getchar();
	return x*f;
}
O3 inline bool cmp(node a,node b)
{
	return a.x<b.x || (a.x==b.x && a.y<b.y);
}
O3 inline ll min(ll x,ll y)
{
	if (!y)return x;if (!x)return y;
	return a[x].y<a[y].y?x:y;
}
O3 inline ll max(ll x,ll y)
{
	if (!y)return x;if (!x)return y;
	return a[x].y>a[y].y?x:y;
}
O3 inline bool judge(ll x,ll y,ll z)
{
	if ((z==1 && a[y].x==a[x+1].x && a[y].y>a[x+1].y)
	|| (z==2 && a[y].x==a[x+1].x && a[y].y<a[x+1].y)
	|| (z==3 && a[y].y==a[x+1].y && a[y].x<a[x+1].x)
	|| (z==4 && a[y].y==a[x+1].y && a[y].x>a[x+1].x))return 0;
	return 1;
}
O3 int main()
{
	//freopen("T3.in","r",stdin);
	n=read();
	fo(i,1,n)a[i].x=read(),a[i].y=read();
	sort(a+1,a+n+1,cmp);
	now=f[0][0][0][0][0]=1;
	fo(i,0,n-1)
	{
		fo(j,1,4)
		{
			bool bz=1;
			fo(k,1,n)if (!judge(i,k,j))
			{
				bz=0;break;
			}
			if (bz)
			{
				fo(l,0,i)fo(r,0,i)
				fo(u,0,i)fo(d,0,i)if (f[las][l][r][u][d])
				{
					if (j==1 && (a[l].y<a[i+1].y || !l))
					(f[now][l][r][min(i+1,u)][d]+=f[las][l][r][u][d])%=mod;//up

					if (j==2 && (a[r].y>a[i+1].y || !r))
					(f[now][l][r][u][max(i+1,d)]+=f[las][l][r][u][d])%=mod;//down

					if (j==3 && ((a[u].y>a[i+1].y && a[d].y<a[i+1].y) || (!u && !d) 
					|| (a[u].y>a[i+1].y && !d) || (a[d].y<a[i+1].y && !u)))
					(f[now][l][r][u][d]+=f[las][l][r][u][d])%=mod;//left

					if (j==4)(f[now][max(i+1,l)][min(i+1,r)][u][d]+=f[las][l][r][u][d])%=mod;//right
				}
			}
		}
		now^=1,las^=1;
		memset(f[now],0,sizeof(f[now]));
	}
	fo(l,0,n)fo(r,0,n)
	fo(u,0,n)fo(d,0,n)(ans+=f[las][l][r][u][d])%=mod;
	printf("%lld\n",ans);
	return 0;
}