根据题意，很明显可以推出DP方程。

假如只考虑向左的方向：

dp[t][i][j]:  第t个时间段末滑行到i,j最长滑行的距离。

dp[t][i][j]=dp[t-1][i][1..k]+(j-k)=dp[t-1][i][1..k]-k+j（k<=j）很明显，可以使用单调队列优化。

最终时间复杂度为O(n*m*k)

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
#define INF ((1<<30)-1)
#define maxn 220
#define LL long long
#define MOD 1000000009
struct list
{
    int x;
    int val;
}node[maxn+maxn],p;
int dp[maxn][maxn][maxn];
int maps[maxn][maxn];
int main()
{
    int i,j,m,n,x,y,k,st,ed,f,t;
    char str[1100];
    while(~scanf("%d%d%d%d%d",&n,&m,&x,&y,&k))
    {
        for(i=1;i<=n;i++)
        {
            scanf("%s",str);
            for(j=1;j<=m;j++)
            {
                if(str[j-1]==‘.‘)maps[i][j]=1;
                else maps[i][j]=0;
            }
        }
        for(i=0;i<=n;i++)
            for(j=0;j<=m;j++)
                for(t=0;t<=k;t++)dp[t][i][j]=-INF;
        int head,tail;
        dp[0][x][y]=0;
        for(t=1;t<=k;t++)
        {
            scanf("%d%d%d",&st,&ed,&f);
            int ti=ed-st+1;
            if(f==1){
                for(j=1;j<=m;j++)
                {
                    head=1;tail=0;
                    for(i=n;i>=1;i--)
                    {
                        if(maps[i][j]){
                            p.val=dp[t-1][i][j]+i;
                            p.x=i;
                            while(tail>=head&&p.val>=node[tail].val)tail--;
                            node[++tail]=p;
                            while(tail>=head&&node[head].x-i>ti)head++;
                            dp[t][i][j]=max(dp[t][i][j],node[head].val-i);
                        }
                        else{
                                head=1,tail=0;
                                dp[t][i][j]=-INF;
                        }
                    }
                }
            }
            if(f==2){
                for(j=1;j<=m;j++)
                {
                    head=1;tail=0;
                    for(i=1;i<=n;i++)
                    {
                        if(maps[i][j]){
                            p.val=dp[t-1][i][j]-i;
                            p.x=i;
                            while(tail>=head&&p.val>=node[tail].val)tail--;
                            node[++tail]=p;
                            while(tail>=head&&i-node[head].x>ti)head++;
                            dp[t][i][j]=max(dp[t][i][j],node[head].val+i);
                        }
                        else{
                                head=1,tail=0;
                                dp[t][i][j]=-INF;
                        }
                    }
                }
            }
            if(f==3){
                for(i=1;i<=n;i++)
                {
                    head=1;tail=0;
                    for(j=m;j>=1;j--)
                    {
                        if(maps[i][j]){
                            p.val=dp[t-1][i][j]+j;
                            p.x=j;
                            while(tail>=head&&p.val>=node[tail].val)tail--;
                            node[++tail]=p;
                            while(tail>=head&&node[head].x-j>ti)head++;
                            dp[t][i][j]=max(dp[t][i][j],node[head].val-j);
                        }
                        else{
                                head=1,tail=0;
                                dp[t][i][j]=-INF;
                        }
                    }
                }
            }
            if(f==4){
                for(i=1;i<=n;i++)
                {
                    head=1;tail=0;
                    for(j=1;j<=m;j++)
                    {
                        if(maps[i][j]){
                            p.val=dp[t-1][i][j]-j;
                            p.x=j;
                            while(tail>=head&&p.val>=node[tail].val)tail--;
                            node[++tail]=p;
                            while(tail>=head&&j-node[head].x>ti)head++;
                            dp[t][i][j]=max(dp[t][i][j],node[head].val+j);
                        }
                        else{
                                head=1,tail=0;
                                dp[t][i][j]=-INF;
                        }
                    }
                }
            }
            for(i=1;i<=n;i++)
            {
                for(j=1;j<=m;j++)
                {
                 //   if(dp[t][i][j]>=0)printf("%2d ",dp[t][i][j]);
                  ///  else printf("%2d ",-1);
                }
              //  cout<<endl;
            }
        }
        int maxx=-1;
        for(t=1;t<=k;t++)
        {
            for(i=1;i<=n;i++)
            {
                for(j=1;j<=m;j++)maxx=max(maxx,dp[t][i][j]);
            }
        }
        cout<<maxx<<endl;
    }
    return 0;
}