[leetcode 905]有效排列

题目链接：leetcode905

题意：

给一个由'D'和'I'组成的字符数组，求0～n这n+1个数满足字符数组所有D和I规则的排列数目，D和I规则如下：

D（decrease）代表a[i] > a[i+1]；

I（increase）代表a[i] < a[i+1].

结果取余10^9+7

题解：

使用动态规划，dp[i][j] 代表当前长度为i并且末尾数字是j的符合规则的排列数目，其中j <= i。那么：

（1）当前字符是D时，当前数字要比上一个字符小，所以

dp[i][j] = dp[i-1][j+1] + dp[i-1][j+2] + ... + dp[i-1][i-1]

但是dp[i-1][ ] 中可能也会出现j。这里的处理方式是，因为当前循环i比上一层循环i-1多了一个数（即上限提升了1），所以可以让所有大于等于j的数都+1，小于j的数不变，这样就不会出现j重复的情况了，而且dp[i-1][j]也可以加入，那么转移方程变成下面：

dp[i][j] = dp[i-1][j] + dp[i-1][j+2] + ... + dp[i-1][i-1]

（2）如果当前字符是I，当前数字要比上一个大，所以：

dp[i][j] = dp[i-1][0] + dp[i-1][1] + ... + dp[i-1][j-1]

这里还是同样的处理，把dp[i-1][ ] 中所有大于等于j的数字+1，小于j的数字不变，就可以把j插在最后了。但转移公式不用变。

代码 O(n^3)：

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;

class Solution {
public:
    int numPermsDISequence(string S) {
        const int mod = 1e9+7;
        int n = S.length() + 1;
        vector<vector<int> > dp(n+1, vector<int>(n+1, 0));
        dp[1][1] = 1;
        int ans = 0;
        for(int i = 2; i <= n; i++){
            for(int j = 1; j <= i; j++){
                if(S[i-2] == 'D'){
                    for(int k = j; k <= n; k++){
                        dp[i][j] = (dp[i][j] + dp[i-1][k]) % mod;
                    }
                }else{
                    for(int k = 1; k < j; k++){
                        dp[i][j] = (dp[i][j] + dp[i-1][k]) % mod;
                    }
                }
                if(i == n){
                    ans = (ans + dp[i][j]) % mod;
                }
            }
        }
        return ans;
    }
};

int main(){
    string S;
    cin>>S;
    Solution s;
    int ans = s.numPermsDISequence(S);
    cout<<ans<<endl;
    return 0;
}

算法还有优化的空间，在计算dp[i][j]时候需要dp[i-1][0~j-1]和dp[i-1][j~i-1]的值，每次都从0~j-1和j~i-1加一遍，存在很多重复计算。这里可以讲dp[i]转换成一个累积数组。举个简单的例子：

给一个长度为n的数组a[n]，有多次询问[l, r]区间的和。我们可以用个f[n]数组记录累积和，f[i]代表区间0～i的和，那么再求[l, r]区间的和时，只需做一个减法运算就可以了：sum(l, r) = dp[r] - dp[l-1]。

下面算法改成O(n^2)，也是用的这个思想。

代码 O(n^2)：

class Solution {
public:
    int numPermsDISequence(string S) {
        const int mod = 1e9+7;
        int n = S.length() + 1;
        vector<vector<int> > dp(n+1, vector<int>(n+1, 0));
        dp[1][1] = 1;
        for(int i = 2; i <= n; i++) dp[1][i] += dp[1][i-1];
        for(int i = 2; i <= n; i++){
            for(int j = 1; j <= i; j++){
                if(S[i-2] == 'D'){
                    dp[i][j] = ((dp[i-1][i-1] - dp[i-1][j-1] + mod) % mod + dp[i][j-1]) % mod;
                }else{
                    dp[i][j] = (dp[i-1][j-1] + dp[i][j-1]) % mod;
                }
            }
        }
        return dp[n][n];
    }
};