0903 DI 序列的排列

我们给出 S，一个源于 {‘D’, ‘I’} 的长度为 n 的字符串 。（这些字母代表 “减少” 和 “增加”。）
有效排列 是对整数 {0, 1, …, n} 的一个排列 P[0], P[1], …, P[n]，使得对所有的 i：

如果 S[i] == ‘D’，那么 P[i] > P[i+1]，以及；
如果 S[i] == ‘I’，那么 P[i] < P[i+1]。
有多少个有效排列？因为答案可能很大，所以请返回你的答案模 10^9 + 7.

思路：

分治算法+区间动态规划

区间动态规划，令 f(i,j) 表示 j−i+1 个数的排列，满足区间 S(i,j−1) 的方案数；

我们每次枚举最大数字的位置，其中可以放在区间开头，放在区间末尾，或者放在区间中某个位置；

放在区间开头时，若 S(i) == ‘D’，则我们转移 f(i,j) += f(i+1,j)；

放在区间末尾时，若 S(j - 1) == ‘I’，则我们转移 f(i,j) += f(i,j−1)；

否则，枚举位置 k in [i+1,j−1]，将区间分为两部分，若S(k - 1) == ‘I’ 并且 S(k) == ‘D’，则 根据乘法原理和组合数计算，转移 f(i,j) += C(len−1,k−i) ∗ f(i,k−1) ∗ f(k+1,j)，其中 C(len−1,k−i) 为组合数，这里代表从 len−1 个数中选择 k−i 个数的方案数。

顺序动态规划+状态压缩

dp[i][j]代表符合DI规则的前i个位置的由j结尾的数组的数目，那么可以求得递推公式：

DI字符串在i位置是’D’：dp[i][j] += dp[i-1][k] for k >= j

DI字符串在i位置是’I’：dp[i][j] += dp[i-1][k] for k < j

由递推公式可以看出我们需要的是dp[i][0],dp[i][1],…,dp[i][j]的和，因此我们改变dp[i][j]的意义，dp[i][j]此时代表前述的和，做到这一点只需要在代码中添加dp[i][j]+=dp[i][j-1]

class Solution:
    def numPermsDISequence(self, S):
        """
        :type S: str
        :rtype: int
        """
        dp = [1] * (len(S) + 1)
        for c in S:
            if c == "I":
                dp = dp[:-1]
                for i in range(1, len(dp)):
                    dp[i] += dp[i - 1]
            else:
                dp = dp[1:]
                for i in range(len(dp) - 1)[::-1]:
                    dp[i] += dp[i + 1]
        return dp[0] % (10**9 + 7)

class Solution:
    def numPermsDISequence(self, S):
        """
        :type S: str
        :rtype: int
        """
        r = [1]
        for si in S:
            if si=='D':
                nr = [0]
                for ri in r[::-1]:
                    nr.append((nr[-1]+ri)%1000000007)
                nr = nr[::-1]
            else:
                nr = [0]
                for ri in r:
                    nr.append((nr[-1]+ri)%1000000007)
            r = nr
        return sum(r)%1000000007