动态规划——Valid Permutations for DI Sequence

We are given S, a length n string of characters from the set {'D', 'I'}. (These letters stand for "decreasing" and "increasing".)

A valid permutation is a permutation P[0], P[1], ..., P[n] of integers {0, 1, ..., n}, such that for all i:

• If S[i] == 'D', then P[i] > P[i+1], and;
• If S[i] == 'I', then P[i] < P[i+1].

How many valid permutations are there?  Since the answer may be large, return your answer modulo 10^9 + 7.

Example 1:

Input: "DID"
Output: 5
Explanation: 
The 5 valid permutations of (0, 1, 2, 3) are:
(1, 0, 3, 2)
(2, 0, 3, 1)
(2, 1, 3, 0)
(3, 0, 2, 1)
(3, 1, 2, 0)

这道题目出自LeetCode,可以采用动态规划方法来解决

这篇博客主要是对LeetCode给出的第一种时间复杂度为O(n^3)的动态规划解法进行解释，题目的大意不再具体解释，有点英文基础的查查百度也能知道
这个题说的是个什么意思。由于采用的是动态规划解法，所以要找出状态和状态转移方程。LeetCode给的那个解法里面把状态dp[i][j]确定为以下的含义：
我们每次只注重最后一个数字在整个数组序列中 小->大 排列后的位置，如果给数组编号为i = 0、1、...、n，我们关注的焦点dp[i][j]可以解释为长度为i+1的数组中某个方案中
其最后一个数字即第i个数字在这i+1个数字中处于第j+1小位置的方案的数量，比如dp[0][0]的意义就是长度为长度为1的数组{0}按字符串S的要求下重新排列后的新数组其第0个数字在整个数组中排最小的方案数字，而且易知dp[0][0]=1。
而且dp[0]只用dp[0][0]这一个元素，其他的用不上，对于每个i = 0、1、...、n,我们只用dp[i][0..i]这些元素。
状态转移方程的解释更加复杂，如果S[i-1]=='D',递减，则p[i]<p[i-1],这个时候dp[i][j]是所有dp[i-1][j<=k<=i-1]的和，k之所以小于i是因为对于dp[i-1]来说它一共就i个成员，下标访问到i会越界，k大等于j的原因不好解释，
有一个替换的问题在里面，因为dp[i]比dp[i-1]多一个元素，它们所代表的数组也是前者比后者多一个，由于dp[i]所属的数组方案中按 小->大的数组和dp[i-1]的那个数组中第k(1<=k<=i)个数字是一样的，这里我不知道怎么叙述好，
反正就是dp[i]所代表的那个长的最后一位可以使用dp[i-1]所代表的那个短的最后一位，因为是递减，可以把dp[i]代表的数组中多出来的那一个最大的数组顶在倒数第二个位置上；如果S[i-1]=='T',由于dp[i]所属的数组方案中按 小->大 
的数组和dp[i-1]的那个数组中第k(1<=k<=i)个数字是一样的，dp[i][j]是所有dp[i-1][0<=k<j]的和。这个题的思路上确实是比较复杂的，也不是很好叙述清楚它的思路。这个题最后一个注意点就是要求模，记住每次求模即可。

下面直接上代码:

int numPermsDISequence(string S){
    int MOD = 1000000007;
    int n = S.length();
    int**dp = new int*[n + 1];
    for (int i = 0; i <= n; i++)
        dp[i] = new int[n + 1];
    for (int i = 0; i <= n;i++)
    for (int j = 0; j <= n; j++){
        if (i == 0)dp[i][j] = 1;
        else dp[i][j] = 0;
    }
    for (int i = 1; i <= n; i++){
        for (int j = 0; j <= i; j++){
            if (S[i - 1] == 'D'){
                for (int k = j; k < i; k++){
                    dp[i][j] += dp[i - 1][k];
                    dp[i][j] %= MOD;
                }
            }
            else{
                for (int k = 0; k < j; k++){
                    dp[i][j] += dp[i - 1][k];
                    dp[i][j] %= MOD;
                }
            }
        }
    }

    for (int i = 0; i <= n; i++){
        for (int j = 0; j <= n; j++)
            cout << dp[i][j] << " ";
        cout << endl;
    }
    

    int ans = 0;
    for (int i = 0; i <= n; i++){
        ans += dp[n][i];
        ans %= MOD;
    }
    for (int i = 0; i <= n; i++)
        delete[]dp[i];
    delete[]dp;
    return ans;
}