题目大意：

定义一个串：只含有 '( )'，'[ ]'，'{ }'，3种（6个）字符。

定义 SS 串：

1. 空串是SS表达式。
2. 若A是SS表达式，且A串中不含有中括号和大括号，则(A)是SS表达式。
3. 若A是SS表达式，且A串中不含有大括号，则[A]是SS表达式。
4. 若A是SS表达式，则{A}是SS表达式。
   
   定义SS串深度：
5. 空串深度为0.
6. 若A可以写成*A'*，其中A‘为SS串，*为任意括号，则\(D(A)=D(A’)+1\)。
7. 若A可以写成BC的形式，其中B、C均是SS串，则\(D(A)=max\{D(B),D(C) \}\)。
   
   求由l1个对括号，l2对中括号，l3对大括号，深度为d 构成的SS串的个数。

题解：这是一道字符串上的计数类 dp 问题，一般对于字符串计数类问题都先把字符串划分成若干个独立的部分，即：划分子问题，再进行求解。首先是状态的选择，\(dp[d][i][j][k]\) 表示深度不超过 d，且由 i，j，k 个对应括号构成的SS串的个数，之所以选择深度不超过 d，是因为若选择深度恰好为 d，将很难从子状态转移到当前状态，或者说，要考虑的情况也比较多。转移到状态转移如下：



在看题解时，看到了另一种比较优秀的解释：对于每一个括号序列可以看成是一棵树的 dfs 序列（类似 dfs 序），树的最大深度是 d，求计数。

记忆化搜搜版代码如下

#include <cstdio>

#include <iostream>

#include <algorithm>

#include <memory.h>

using namespace std;

const int mod=11380;

int dp[31][11][11][11],l1,l2,l3,d;

int dfs(int dep,int x,int y,int z){

	int &ans=dp[dep][x][y][z];

	if(dep<0)return 0;

	if(!dep){

		if(x+y+z==0)return 1;

		else return 0;

	}

	if(x+y+z==0)return 1;

	if(ans>=0)return ans;

	int cnt=0;

	for(int i=0;i<x;i++)

		for(int j=0;j<=y;j++)

			for(int k=0;k<=z;k++)

				cnt=(cnt+(long long)dfs(dep-1,i,j,k)*dfs(dep,x-1-i,y-j,z-k))%mod;

	for(int j=0;j<y;j++)

		for(int k=0;k<=z;k++)

			cnt=(cnt+(long long)dfs(dep-1,0,j,k)*dfs(dep,x,y-1-j,z-k))%mod;

	for(int k=0;k<z;k++)cnt=(cnt+(long long)dfs(dep-1,0,0,k)*dfs(dep,x,y,z-1-k))%mod;

	return ans=cnt;

}

int main(){

	scanf("%d%d%d%d",&l1,&l2,&l3,&d);

	memset(dp,-1,sizeof(dp));

	printf("%d\n",(dfs(d,l1,l2,l3)-dfs(d-1,l1,l2,l3)+mod)%mod);

	return 0;

}

迭代版代码如下

#include <cmath>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

const int P = 11380;

const int M = 35;

const int N = 15;

int f[N][N][N][M];

int fun(int a, int b, int c, int d) {

    if (a + b + c == 0) return 1;

    int tmp = 0;

    for (int i = 0; i < c; i++)

        tmp = (tmp + f[a][b][c - i - 1][d] * f[0][0][i][d - 1]) % P;

    for (int i = 0; i < b; i++)

        for (int j = 0; j <= c; j++)

            tmp = (tmp + f[a][b - i - 1][c - j][d] * f[0][i][j][d - 1]) % P;

    for (int i = 0; i < a; i++)

        for (int j = 0; j <= b; j++)

            for (int k = 0; k <= c; k++)

                tmp = (tmp + f[a - i - 1][b - j][c - k][d] * f[i][j][k][d - 1]) % P;

    return tmp;

}

int main() {

    int l1, l2, l3, d;

    cin >> l1 >> l2 >> l3 >> d;

    f[0][0][0][0] = 1;

    for (int i = 0; i <= l1; i++)

        for (int j = 0; j <= l2; j++)

            for (int k = 0; k <= l3; k++)

                for (int l = 1; l <= d; l++)

                    f[i][j][k][l] = fun(i, j, k, l);

    if (d) f[l1][l2][l3][d] = (f[l1][l2][l3][d] - f[l1][l2][l3][d - 1] + P) % P;

    cout << f[l1][l2][l3][d] << endl;

    return 0;

}