hdu 4005 Number String 数列上的DP 【From：2011 Asia Dalian Regional Contest】&& 【SGU489】 Extremal Permutations

题意：一个1~n的序列，分别用'I','D'表示序列的升降，如{1,2,4,3}，则是属于IID的情况，而1~4中属于IID情况的可以有很多不同的序列，给出序列的I、D表现形式（‘?’表示‘I’或‘D’都可以），求出满足这样要求的有多少种。

例如：

Sample Input
II
ID
DI
DD
?D
??
 

Sample Output
1
2
2
1
3
6
Hint

Permutation {1,2,3} has signature "II".
Permutations {1,3,2} and {2,3,1} have signature "ID".
Permutations {3,1,2} and {2,1,3} have signature "DI".
Permutation {3,2,1} has signature "DD".
"?D" can be either "ID" or "DD".
"??" gives all possible permutations of length 3.
 

可以用dp[i][j]表示：处理完第i位，序列末尾位j的序列共有多少个。最后的结果为sigma{dp[N][i]}，1≤i≤N

处理dp[1~i][]的过程中i是依次1~n相加。处理完dp[i-1][]后，加入的数即为i，而dp[i][j]是要将i放进去j换出来，而这里有一种将i放进去j换出来，同时不影响升降顺序的方法是：

将dp[i-1][j]的i-1个数的序列中 ≥j 的数都加1，这样i-1变成了i，j变成了j+1，而j自然就补在后面了。

所以对”ID“序列依次处理即可，初始条件：dp[1][1] = 1; 即只有{1}。

处理‘I’：dp[i][j] = sigma{dp[i-1][x]}，其中1≤x≤j-1，可进一步简化，dp[i][j] = dp[i-1][j-1]+dp[i-1][j-1]

处理‘D’：dp[i][j] = sigma{dp[i-1][x]}，其中j≤x≤i-1，可进一步简化，dp[i][j] = dp[i-1][j+1]+dp[i-1][j]

处理‘?’：dp[i][j] = sigma{dp[i-1][x]}，其中1≤x≤i-1，直接计算

处理过程中在注意边界和取模问题就可以了，附上代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#define MAXN 1010
using namespace std;
const int mod = 1000000007;
char str[MAXN];

int dp[MAXN][MAXN];
int main(){
    int N;
    char ch;
    while(~scanf("%s",str)){
        N=strlen(str)+1;
        memset(dp,0,sizeof(dp));
        dp[1][1]=1;
        for(int i=2;i<=N;i++){
            ch = str[i-2];
            if(ch=='?'){
                int sum=0;
                for(int j=1;j<=i-1;j++)sum = (sum+dp[i-1][j])%mod;
                for(int j=1;j<=i;j++){
                    dp[i][j]=sum;
                }
            }
            else if(ch=='I'){
                for(int j=2;j<=i;j++){
                    dp[i][j]=(dp[i][j-1]+dp[i-1][j-1])%mod;
                }
            }
            else{
                for(int j=i-1;j>=1;j--){
                    dp[i][j]=(dp[i][j+1]+dp[i-1][j])%mod;
                }
            }
        }
        int res=0;
        for(int i=1;i<=N;i++){
            res = (res+dp[N][i])%mod;
        }
        printf("%d\n",res);
    }
    return 0;
}

另外一道题SGU489，求法和上道题类似~~【该死去年过的大连赛区的题，今年做这题居然想不起来】

题意：给出一个n，求1~n的排列中，满足IDIDID……或DIDIDID……的序列有多少个。

dp[i][j][0]：处理完第i个数后最后一位数是j，且倒数第二位至最后一位的趋势是下降；

dp[i][j][1]：处理完第i个数后最后一位数是j，且倒数第二位至最后一位的趋势是上升。

 转移方程：

dp[i][j][0] = sigma{dp[i-1][x][1]}，其中j≤x≤i-1，可进一步简化，dp[i][j][0] = dp[i-1][j+1][0]+dp[i-1][j][1]

dp[i][j][1] = sigma{dp[i-1][x][0]}，其中1≤x≤j-1，可进一步简化，dp[i][j][1] = dp[i-1][j-1][1]+dp[i-1][j-1][0]

最后求sigma{dp[N][i][0]+dp[N][i][1]}，1≤i≤N。注意初始条件为dp[1][1][0] = dp[1][1][1] = 1;所以n==1时要特判一下。当然还需要用到滚动数组优化一下空间，上一题其实也可以用滚动数组，不过范围不大也没必要，代码如下：

Time: 953 MS

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;

int dp[2][10005][2];
int main(){
    int n, m, i, j;
    int ans;
    while(~scanf("%d%d",&n,&m)){
        if(n==1){
            printf("%d\n",n%m);continue;
        }
        memset(dp,0,sizeof(dp));
        dp[1][1][0] = dp[1][1][1] = 1;
        for(i=2;i<=n;i++){
            for(j=i;j>=1;j--){
                dp[i&1][j][0] = (dp[i&1][j+1][0]+dp[(i-1)&1][j][1])%m;
            }
            for(j=1;j<=i;j++){
                dp[i&1][j][1] = (dp[i&1][j-1][1]+dp[(i-1)&1][j-1][0])%m;
            }
        }
        ans = 0;
        for(j=1;j<=n;j++){
            ans = (ans+(dp[n&1][j][0]+dp[n&1][j][1])%m)%m;//这里很坑爹，一定要两个相加后取模，不然就暴int了
//当然如果直接用long long就不会了，不过dp数组用long long的超空间问题不能实现，那么三个连加就不知道什么情况了。
        }
        printf("%d\n",ans%m);
    }
    return 0;
}

还有一个优化版本，利用的性质是对称性：dp[i][j][0] = dp[i][i-j][1]。

最后求sigma{dp[N][i][0]+dp[N][i][1]}，1≤i≤N。也就是sigma{dp[N][i][0]}*2了，所以可以少计算dp[i][j][0]。

Time: 500 MS

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;

int dp[2][10005];
int main(){
    int n, m, i, j;
    int ans;
    while(~scanf("%d%d",&n,&m)){
        if(n==1){
            printf("%d\n",n%m);continue;
        }
        memset(dp,0,sizeof(dp));
        dp[1][1] = 1;
        for(i=2;i<=n;i++){
            for(j=i;j>=1;j--){
                dp[i&1][j] = (dp[i&1][j+1]+dp[(i-1)&1][i-j])%m;
            }
        }
        ans = 0;
        for(j=1;j<=n;j++){
            ans = (ans+dp[n&1][j])%m;
        }
        printf("%d\n",(ans+ans)%m);
    }
    return 0;
}