九度oj 1547

题目描述：

给定一个初始为空的栈，和n个操作组成的操作序列，每个操作只可能是出栈或者入栈。
要求在操作序列的执行过程中不会出现非法的操作，即不会在空栈时执行出栈操作，同时保证当操作序列完成后，栈恰好为一个空栈。
求符合条件的操作序列种类。
例如，4个操作组成的操作序列符合条件的如下：
入栈，出栈，入栈，出栈
入栈，入栈，出栈，出栈
共2种。

输入：

输入包含多组测试用例，每组测试用例仅包含一个整数n(1<=n<=1000)。

输出：

输出仅一个整数，表示符合条件的序列总数，为了防止总数过多超出int的范围，结果对1000000007取模(mod 1000000007)。

样例输入：

2
4
10

样例输出：

1
2
42

 /*i = 3; j = 1
 111 0
 110 1
 101 1

 i = 2; j = 1
 110
 101

 i = 3 j = 0
 111
 3 3 = 2 3 + 3 2
 i = 3; j = 2
 1110 0
 1101 0
 1011 0
 1100 1
 1010 1

 i = 2; j = 2
 1100
 1010

 i = 3; j = 1
 1110
 1101
 1011
 */
 /*
 状态dp[i][j](i >= j)表示入栈i次出栈j次的种类数

 状态转移方程：dp[i][j] = dp[i-1][j] + dp[i][j-1]
　　　　　　　　　　　　     最后一个是入栈    最后一个是出栈
 */
 #include <cstdio>
 #include <cstdlib>
 #define MAX 1002

 int dp[MAX][MAX];
 int top(int n) {
     int temp = n/;
     if(temp * == n) {
         return temp;
     }
     return temp + ;
 }
 int main(int argc, char const *argv[])
 {
     int n;
     for(int i = ; i < ; i++) {
             dp[i][] = ;
             dp[][i] = ;
         }
         for(int i = ; i <= ; i++) {
             for(int j = ; j <= ; j++) {
                 if(i >= j) {
                     dp[i][j] = (dp[i-][j] + dp[i][j-])%;
                 }
                 else {
                     dp[i][j] = ;
                 }
             }
         }
     while(scanf("%d",&n) != EOF) {
         if(n & ) {
             printf("%d\n",);
         }
         else  {
             printf("%d\n",dp[n/][n/]);
         }

     }
     return ;
 }
  

　　这道题一开始完全没有思路，最重要的是得出状态转移方程，利用动态规划求解。

　　另外，while(scanf("%d",&n))会导致结果output limit exceed

　　要写成 while(scanf("%d",&n) != EOF)

　　还有，题目说“同时保证当操作序列完成后，栈恰好为一个空栈”不是说它的输入保证这一点，而是如果有这样的输入，答案是0，也就是如果输入时奇数，答案是0