【POJ1187】陨石的秘密

题目大意：
定义一个串：只含有 '( )'，'[ ]'，'{ }'，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 
#include 
#include 
#include 
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

迭代版代码如下

#include 
#include 
#include 
#include 
#include 
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;
}

转载于:https://www.cnblogs.com/wzj-xhjbk/p/9990835.html