HDOJ 题目4055 Number String（DP）

Number String

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1623    Accepted Submission(s): 738

Problem Description

The signature of a permutation is a string that is computed as follows: for each pair of consecutive elements of the permutation, write down the letter 'I' (increasing) if the second element is greater than the first one, otherwise write down the letter 'D' (decreasing). For example, the signature of the permutation {3,1,2,7,4,6,5} is "DIIDID".

Your task is as follows: You are given a string describing the signature of many possible permutations, find out how many permutations satisfy this signature.

Note: For any positive integer n, a permutation of n elements is a sequence of length n that contains each of the integers 1 through n exactly once.

 

Input

Each test case consists of a string of 1 to 1000 characters long, containing only the letters 'I', 'D' or '?', representing a permutation signature.

Each test case occupies exactly one single line, without leading or trailing spaces.

Proceed to the end of file. The '?' in these strings can be either 'I' or 'D'.

 

Output

For each test case, print the number of permutations satisfying the signature on a single line. In case the result is too large, print the remainder modulo 1000000007.

 

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.

   
   
   
    
  
  

 

Author

HONG, Qiz

思路：

http://blog.csdn.net/cc_again/article/details/10858813

题目大意：

给一个只含‘I','D','?'三种字符的字符串，I表示当前数字大于前面的数字，D表示当前的数字小于前面一位的数字，？表示当前位既可以小于又可以大于。

问1~n的排列中有多少个满足该字符串。

解题思路：

计数dp.

dp[i][j]表示长度为i字符串，最后一个数为j时，能达到满足给定字符串的1~i+1的排列个数。

转移方程：

当S[i]='I'时，当前如果为j的话，前面的一位肯定要小于j,dp[i][j]+=Mi[j-1] ; //Mi[i]表示前面一位下标小于等于i dp[][1~i]的和

当S[i]='D'时，dp[i][j]+=(la-Mi[j-1]);  //前一位要大于等于j

当S[i]='?'时，dp[i][j]+=la; //la表示前一位所有的状态总和.

注意递推的时候，前i位只和相对大小有关，与绝对大小无关，所以都用1~i表示，当增加一位时，就变成了1~i+1，如果当前为j,前面的小于j的状态不变，大于等于j的状态k所表示的值 现在表示k+1的值，这样就从1~i等价的转化成了1~i+1,这样考虑就不用考虑1~n的放法了，递推到n位时肯定都是1~n了。

ac代码

 

天了撸了，，64位超时，，int过了，，见过int超，int64过的，这还是第一次。。。

#include<stdio.h>
#include<string.h>
#define maxn 1010
#define  LL __int64
#define mod 1000000007
int dp[1010][1010];
int mi[1010][2];
int la;
char str[1010];
void init(int len)
{
    int i,j;
    for(i=0;i<len+10;i++)
    {
        mi[i][1]=mi[i][0]=0;
        for(j=0;j<len+10;j++)
        {
            dp[i][j]=0;
        }
    }
}
int main()
{
    while(scanf("%s",str+1)!=EOF)
    {
        int len=strlen(str+1);
        memset(dp,0,sizeof(dp));
        memset(mi,0,sizeof(mi));
    //    init(len);
        dp[0][1]=1;
        la=1;
        mi[1][0]=1;
        int p=0;
        int i,j;
        for(i=1;i<=len;i++)
        {
            p=p^1;
            int temp=0;
            for(j=1;j<=i+1;j++)
            {
                if(str[i]=='I')
                {
                    dp[i][j]=(dp[i][j]+mi[j-1][p^1])%mod;
                }
                else
                    if(str[i]=='D')
                        dp[i][j]=(dp[i][j]+(la-mi[j-1][p^1])+mod)%mod;
                    else
                        dp[i][j]=(dp[i][j]+la)%mod;
                mi[j][p]=(mi[j-1][p]+dp[i][j])%mod;
                temp=(temp+dp[i][j])%mod;
            }
            la=temp;
        }
        int ans=0;
        for(i=1;i<=len+1;i++)
        {
            ans=(ans+dp[len][i])%mod;
        }
        printf("%d\n",ans);
    }
}