bzoj1499 [NOI2005]瑰丽华尔兹

很容易想出O(NMT)的算法，枚举时间，然后枚举位置，转移就好了，大概是f[t][i][j]=max(f[t-1][i][j],f[t-1][i-dx[t]][j-dy[t]]+1)  dx,dy表示某时刻的滑行方向。这样显然过不了，但是看到每一时间段滑行的方向是相同的，也就是只会在一条直线上转移，于是可以用单调队列维护这一条线上的最优值。当某位置是障碍的时候，这个点不能转移或者被转移，那么清空队列；当转移长度大于时间段长度的时候，当前值不合法，需要后移队首指针；当不动比队尾还要优的时候，队尾永远不可能成为最优值，那么前移队尾指针。这样枚举时间段，枚举位置就可以了，O(NMK)。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#define maxn 220
#define inf 2147483647
using namespace std;
char map[maxn][maxn];
int f[2][maxn][maxn],q[maxn];
int n,m,p,sx,sy,st,ed,dir,now,last,ans;

int main()
{
    scanf("%d%d%d%d%d",&n,&m,&sx,&sy,&p);
    for (int i=1;i<=n;i++) scanf("%s",map[i]+1);
    now=1; last=0;
    memset(f,200,sizeof(f));
    if (map[sx][sy]!='x') f[now][sx][sy]=0;
    for (int k=1;k<=p;k++)
    {
        scanf("%d%d%d",&st,&ed,&dir);
        int len=ed-st+1;
        now^=1; last^=1;
        memset(f[now],200,sizeof(f[now]));
        switch (dir)
        {
            case 1:
                for (int j=1;j<=m;j++)
                {
                    int head=1,tail=0;
                    for (int i=n;i>=1;i--)
                    {
                        f[now][i][j]=f[last][i][j];
                        if (map[i][j]=='x') head=1,tail=0;
                        while (head<=tail&&f[last][i][j]>f[last][q[tail]][j]+q[tail]-i) tail--;
                        q[++tail]=i;
                        while (head<=tail&&i+len<q[head]) head++;
                        if (head<=tail) f[now][i][j]=max(f[now][i][j],f[last][q[head]][j]+q[head]-i);
                    }
                }                        
                break;
            case 2:
                for (int j=1;j<=m;j++)
                {
                    int head=1,tail=0;
                    for (int i=1;i<=n;i++)
                    {
                        f[now][i][j]=f[last][i][j];
                        if (map[i][j]=='x') head=1,tail=0;
                        while (head<=tail&&f[last][i][j]>f[last][q[tail]][j]+i-q[tail]) tail--;
                        q[++tail]=i;
                        while (head<=tail&&i-len>q[head]) head++;
                        if (head<=tail) f[now][i][j]=max(f[now][i][j],f[last][q[head]][j]+i-q[head]);
                    }
                }
                break;
            case 3:
                for (int i=1;i<=n;i++)
                {
                    int head=1,tail=0;
                    for (int j=m;j>=1;j--)
                    {
                        f[now][i][j]=f[last][i][j];
                        if (map[i][j]=='x') head=1,tail=0;
                        while (head<=tail&&f[last][i][j]>f[last][i][q[tail]]+q[tail]-j) tail--;
                        q[++tail]=j;
                        while (head<=tail&&j+len<q[head]) head++;
                        if (head<=tail) f[now][i][j]=max(f[now][i][j],f[last][i][q[head]]+q[head]-j);
                    }
                }
                break;
            case 4:
                for (int i=1;i<=n;i++)
                {
                    int head=1,tail=0;
                    for (int j=1;j<=m;j++)
                    {
                        f[now][i][j]=f[last][i][j];
                        if (map[i][j]=='x') head=1,tail=0;
                        while (head<=tail&&f[last][i][j]>f[last][i][q[tail]]+j-q[tail]) tail--;
                        q[++tail]=j;
                        while (head<=tail&&j-len>q[head]) head++;
                        if (head<=tail) f[now][i][j]=max(f[now][i][j],f[last][i][q[head]]+j-q[head]);
                    }
                }
            break;
        }
    }
    ans=0;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (f[now][i][j]>ans) ans=f[now][i][j];
    printf("%d\n",ans);
    return 0;
}