九度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/2;
    if(temp *2 == n) {
        return temp;
    }
    return temp + 1;
}
int main(int argc, char const *argv[])
{
    int n;
    for(int i = 0; i < 502; i++) {
            dp[i][0] = 1;
            dp[0][i] = 0;
        }
        for(int i = 1; i <= 502; i++) {
            for(int j = 1; j <= 502; j++) {
                if(i >= j) {
                    dp[i][j] = (dp[i-1][j] + dp[i][j-1])%1000000007;
                }
                else {
                    dp[i][j] = 0;
                }
            } 
        }
    while(scanf("%d",&n) != EOF) {
        if(n & 1) {
            printf("%d
",0);
        }
        else  {
            printf("%d
",dp[n/2][n/2]);
        }
        
        
    }
    return 0;
}
 

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

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

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

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