2014-2015 ACM-ICPC, NEERC K Kebab House（dp）

题意：有n个时间块，每个pi时间块要煎至少xi次披萨，其余时间可以做梦，要求是每2次做梦间隔要大于等于(t+1)，问合法情况总数。

做法：我们可以发觉，每个块对于后面的块影响只有最后一个做梦的时间离最后的距离，所以我们用pre[i]表示最后一个做梦的时间离最后距离为i的情况总数。每个块可以单独算，令dp[i][j]为第i个位置做梦，且总做梦数为j次的情况总数，可以发觉dp[i][1]是由前一个块的转移过来，而其余的都是由dp[k][j-1]（k <= i-t）之和转移过来，这样我们可以维护一个前缀和就可以做到o(1)的转移。

总复杂度是o(n*q*q)的，我们可以加一个减枝，比如做梦次数不能太多啊。。然后就可以挺快的过了～～

AC代码：

#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<ctype.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<cmath>
#include<ctime>
#include<string.h>
#include<string>
#include<sstream>
#include<bitset>
using namespace std;
#define ll __int64
#define ull unsigned __int64
#define eps 1e-8
#define NMAX 1000000000
#define MOD 1000000007
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI acos(-1)
template<class T>
inline void scan_d(T &ret)
{
    char c;
    int flag = 0;
    ret=0;
    while(((c=getchar())<'0'||c>'9')&&c!='-');
    if(c == '-')
    {
        flag = 1;
        c = getchar();
    }
    while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
    if(flag) ret = -ret;
}
const int maxn = 4000+10;

int dp[255][255], pre[1005][105], sum[1005][105];
int sd[255];
int a[1005][2];

void add(int &a, int b)
{
    a += b;
    if(a >= MOD) a -= MOD;
}

int main()
{
#ifdef GLQ
    freopen("input.txt","r",stdin);
//    freopen("o1.txt","w",stdout);
#endif
//    freopen("kebab.in","r",stdin);
//    freopen("kebab.out","w",stdout);
    int n,t;
    while(~scanf("%d%d",&n,&t))
    {
        t++;
        for(int i = 1; i <= n; i++)
            scanf("%d%d",&a[i][0],&a[i][1]);
        for(int i = 0; i <= n; i++)
            for(int j = 0; j <= t; j++) pre[i][j] = sum[i][j] = 0;
        for(int i = 0; i <= t; i++) sum[0][i] = 1;
        pre[0][t] = 1;
        for(int p = 1; p <= n; p++)
        {
            memset(sd,0,sizeof(sd));
            for(int i = 1; i <= a[p][0]; i++)
            {
                dp[i][0] = 0;
                if(i-t >= 1)
                {
                    int lim = a[p][0]-a[p][1] > i-t ? i-t :  a[p][0]-a[p][1];
                    for(int j = 1; j <= lim; j++) add(sd[j],dp[i-t][j]);
                }
                int lim = a[p][0]-a[p][1] > i ? i : a[p][0]-a[p][1];
                for(int j = 1; j <= lim; j++)
                {
                    if(j == 1)
                    {
                        int tmp = i >= t ? 0 : t-i;
                        dp[i][j] = sum[p-1][tmp];
                    }
                    else
                    {
                        if(i < t)
                        {
                            dp[i][j] = 0;
                            continue;
                        }
                        dp[i][j] = sd[j-1];
                    }
                    int ha = a[p][0]-i >= t ? t : a[p][0]-i;
                    add(pre[p][ha],dp[i][j]);
                }
            }
            for(int i = 0; i <= t; i++)
            {
                int ha = i+a[p][0] >= t ? t : i+a[p][0];
                add(pre[p][ha],pre[p-1][i]);
            }
            sum[p][t] = pre[p][t];
            for(int i = t-1; i >= 0; i--) sum[p][i] = ((ll)pre[p][i]+sum[p][i+1])%MOD;
        }
        printf("%d\n",sum[n][0]);
    }
    return 0;
}