zoj 2604 Little Brackets（动态规划+递推+java）

给定一个长度为2n的括号序列，问深度为k的子序列有多少个

因为涉及到大数，所以用java写比较方便

状态转移不太好想

我们用dp[n][k]表示长度为2n的括号序列，深度小于等于k的子序列个数

对于任意一个序列都可以化为（X）Y形式

对应的状态转移方程为dp[n][k] = dp[i-1][k-1]*dp[n-i][k];

其中i表示序列X的长度，则X对应的dp值为dp[i-1][k-1], Y对应的dp值为dp[n-i][k]

根据乘法定理即得上式

代码如下：

import java.util.*;
import java.math.*;

public class Main {
    static BigInteger dp[][] = new BigInteger[55][55];

    static void solve(int n, int k) {
        for(int i=0; i<=n; ++i)
            for(int j=0; j<=k; ++j)
                dp[i][j] = BigInteger.ZERO;

        for(int i=0; i<=n; ++i)
            dp[0][i] = BigInteger.ONE;

        for(int i=1; i<=n; ++i) {
            for(int j=1; j<=k; ++j) {
                for(int p=1; p<=i; ++p) {
                    dp[i][j] = dp[i][j].add(dp[i-p][j].multiply(dp[p-1][j-1]));
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int cnt = 1;
        while(in.hasNext()) {
            int n = in.nextInt();
            int k = in.nextInt();
            if(n==0 && k==0)
                break;
            solve(n, k);
            if(cnt > 1)
                System.out.println("");
            System.out.printf("Case %d: ", cnt++);
            System.out.println(dp[n][k].subtract(dp[n][k-1]));
        }
    }
}