[BZOJ 4350]括号序列再战猪猪侠 题解（区间DP）

[BZOJ 4350]括号序列再战猪猪侠

Description

括号序列与猪猪侠又大战了起来。

众所周知，括号序列是一个只有(和)组成的序列，我们称一个括号

序列S合法，当且仅当:

1.( )是一个合法的括号序列。

2.若A是合法的括号序列，则(A)是合法的括号序列。

3.若A，B是合法的括号序列，则AB是合法的括号序列。

我们考虑match[i]表示从左往右数第i个左括号所对应的是第几个右

括号，现在他得到了一个长度为2n的括号序列，给了你m个信息，第i

个信息形如ai,bi，表示match[ai]<match[bi]，要你还原这个序列。

但是你发现这个猪猪侠告诉你的信息，可能有多个括号序列合法；甚

至有可能告诉你一个不存在合法括号序列的信息！

你最近学了取模运算，你想知道答案对998244353(7172^23+1)取

模的结果，这个模数是一个质数。

Input

第一行一个正整数T,T< = 5，表示数据组数。

对于每组数据，第一行一个n,m，n表示有几个左括号，m表示信息数。

接下来m行，每行两个数ai,bi，1< = ai,bi< = n。

Output

对于每组数据，输出一个数表示答案。

Solution

1.对于限制条件match[i]<match[j],记录v[i][j]=1。在所有条件记录结束后，处理二维前缀和，用于dp转移合法性的判断；

当sum[x1...x2][y1...y2]>0时，即代表[x1...x2]中的元素对[y1...y2]中的元素有限制。

补充：求二维区间和办法：O(n^2)预处理前缀和，O（1）询问结果：

对于v[x1...x2][y1...y2]（x1<=x2,y1<=y2）,

ans=v[x2][y2]-v[x1-1][y2]-v[x2][y1-1]+v[x1-1][y1-1],即：

inline ll sum(ll x1,ll x2,ll y1,ll y2){
	return v[x2][y2]-v[x1-1][y2]-v[x2][y1-1]+v[x1-1][y1-1];
}

2.对与待处理区间[l,r],将其用第一个左括号对应的右括号的位置划分并转移：

（1）第一个括号对应的右括号在它旁边，当且仅当其后方对其没有限制时，

即sum(l+1,r,l,l)=0，转移为 f[l][r]=(f[l][r]+f[l+1][r])%mod;

（2）第一个括号对应的右括号在整个区间右边，当且仅当其对后方没有限制时，

即sum(l,l,l+1,r)=0，转移同上；

（3）第一个括号对应的右括号在区间内，在第k个左括号右侧时，此时应满足：

a.右半段对左半端没有限制，即 sum(k+1,r,l,k)=0；

b.第一个括号对左半个区间没有限制时，即 sum(l,l,l+1,k)=0；

转移为方案数加上左侧方案数右侧方案数，即 f[l][r]=(f[l][r]+f[l+1][k]f[k+1][r])%mod;

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
typedef long long ll;
using namespace std;

ll t,n,m,v[500][500],f[500][500];
const ll mod=998244353;

inline ll rd(){
	ll x=0;
	bool f=0;
	char c=getchar();
	while(!isdigit(c)){
		if(c=='-')f=1;
		c=getchar();
	}
	while(isdigit(c)){
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return f?-x:x;
}

void init(){
	n=rd();
	m=rd();
	memset(f,0,sizeof(f));
	memset(v,0,sizeof(v));
	for(ll i=1;i<=m;++i)v[rd()][rd()]=1;
	for(ll i=1;i<=n;++i)
		for(ll j=1;j<=n;++j)
			v[i][j]=v[i-1][j]+v[i][j-1]+v[i][j]-v[i-1][j-1];
}

inline ll sum(ll x1,ll x2,ll y1,ll y2){
	return v[x2][y2]-v[x1-1][y2]-v[x2][y1-1]+v[x1-1][y1-1];
}

void dp(){
	for(ll i=1;i<=n;++i){
		f[i][i]=1;
		if(sum(i,i,i,i)==1){
			putchar('0');
			putchar('\n');
			return;
		}
	}
	for(ll len=2;len<=n;++len)
		for(ll l=1;l<=n-len+1;++l){
			ll r=l+len-1;
			if(!sum(l,l,l+1,r)) f[l][r]=(f[l][r]+f[l+1][r])%mod;
			if(!sum(l+1,r,l,l)) f[l][r]=(f[l][r]+f[l+1][r])%mod;
			for(ll k=l;k<=r;++k)
		 		if((!sum(k+1,r,l,k))&&(!sum(l,l,l+1,k)))
		 			f[l][r]=(f[l][r]+f[l+1][k]*f[k+1][r])%mod;
		}
	printf("%lld\n",f[1][n]);
}

int main(){
	t=rd();
	while(t--){init();dp();}
	return 0;
}

有关区间DP的其他讲解参考我的随笔：http://www.cnblogs.com/COLIN-LIGHTNING/p/9038198.html