2412. 【NOI2005】瑰丽华尔兹

题目描述

　　你跳过华尔兹吗？当音乐响起，当你随着旋律滑动舞步，是不是有一种漫步仙境的惬意？
　　众所周知，跳华尔兹时，最重要的是有好的音乐。但是很少有几个人知道，世界上最伟大的钢琴家一生都漂泊在大海上，他的名字叫丹尼·布德曼·T.D.·柠檬·1900，朋友们都叫他1900。
　　1900出生于20世纪的第一年出生在往返于欧美的邮轮弗吉尼亚号上，然后就被抛弃了。1900刚出生就成了孤儿，孤独的成长在弗吉尼亚号上，从未离开过这个摇晃的世界；也许是对他命运的补偿，上帝派可爱的小天使艾米丽照顾他。
　　可能是天使的点化，1900拥有不可思议的钢琴天赋，从未有人教，从没看过乐谱，但他却能凭着自己的感觉弹出最沁人心脾的旋律。当1900的音乐获得邮轮上所有人的欢迎时，他才8岁，而此时他已经乘着海轮往返欧美50多次了。
　　虽说是钢琴奇才，但1900还是个8岁的孩子，他有着和一般男孩一样的好奇的调皮，不过可能更有一层浪漫的色彩罢了：
　　这是一个风雨交加的夜晚，海风卷起层层巨浪拍打着弗吉尼亚号，邮轮随着巨浪剧烈的摇摆。船上的新萨克斯手迈克斯·托尼晕船了，1900将他邀请到舞厅，然后——，然后松开了固定钢琴的闸，于是，钢琴随着海轮的倾斜滑动起来。准确的说，我们的主角1900、钢琴、邮轮随着1900的旋律一起跳起了华尔兹，所有的事物好像都化为一体，随着“强弱弱”的节奏，托尼的晕船症也奇迹般地一点一点恢复。正如托尼在回忆录上这样写道：
　　　　大海摇晃着我们
　　　　使我们转来转去
　　　　快速的掠过灯和家具
　　　　我意识到我们正在和大海一起跳舞
　　　　真是完美而疯狂的舞者
　　晚上在金色的地板上快乐的跳着华尔兹是不是很惬意呢？也许，我们忘记了一个人，那就是艾米丽，她可没闲着：她必须在适当的时候施魔法帮助1900，不让钢琴碰上舞厅里的家具。而艾米丽还小，她无法施展魔法改变钢琴的运动方向或速度，而只能让钢琴停一下。
　　不妨认为舞厅是一个N行M列的矩阵，矩阵中的某些方格上堆放了一些家具，其他的则是空地。钢琴可以在空地上滑动，但不能撞上家具或滑出舞厅，否则会损坏钢琴和家具，引来难缠的船长。
　　每个时刻，钢琴都会随着船体倾斜的方向向相邻的方格滑动一格，其中相邻的方格可以是向东、向西、向南或向北的。而艾米丽可以选择施魔法或不施魔法，如果不施魔法，则钢琴会滑动，而如果施魔法，则钢琴会原地不动。
　　艾米丽是个天使，她知道每段时间的船体的倾斜情况。她想使钢琴尽量长时间在舞厅里滑行，这样1900会非常高兴，同时也有利于治疗托尼的晕船。但艾米丽还太小，不会算，所以希望你能帮助她。

题目分析

50分方法：
我们可以想到用DP来实现，设$f[i][j][k]$为第i行第j列，在k个时刻后最少的施魔法次数，我们便可以得到状态转移方程：

$$f[i][j][k]=min(f[i][j][k-1]+1,f[x][y][k-1])$$
其中x，y为移动前的位置。
时间复杂度 $O(Tnm)$

100分方法：
这一道题我们可以用单调队列来维护。
以向上为例，如果一个点可以通过两个点i，j得到。
我们假设i离这个点更近些，则如果$f[j.x][j.y][k]-(x[j]-x[i])>f[i.x][i.y][k]$
则第j个点是没有意义的，所以我们可以删掉。
时间复杂度$O(knm)$

代码

#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
int f[210][210][210];
char s[210][210];
int dx[4]={-1,1,0,0};
int dy[4]={0,0,-1,1};
struct node
{
    int l,r,d;
}tr[210];
struct duilie
{
    int x,y,c;
}b[210];
int mymin(int x,int y) {return x<y?x:y;}
int main()
{
    int n,m,x,y,kk;
    scanf("%d%d%d%d%d",&n,&m,&x,&y,&kk);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s[i]+1);
    }
    for(int i=1;i<=kk;i++)
    {
        scanf("%d%d%d",&tr[i].l,&tr[i].r,&tr[i].d);
    }
    int t=tr[kk].r;
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k<=kk;k++)
            {
                f[i][j][k]=999999999;
            }
        }
    }
    f[x][y][0]=0;
    for(int i=1;i<=kk;i++)
    {
        if(tr[i].d==1)
        {
            for(int j=1;j<=m;j++)
            {
                int l=1,r=0;
                for(int k=n;k>=1;k--)
                {
                    if(s[k][j]=='.')
                    {
                        if(f[k][j][i-1]!=999999999)
                        {
                            while(b[r].c-abs(k-b[r].x)>f[k][j][i-1]&&l<=r) r--;
                            r++;
                            b[r].c=f[k][j][i-1];
                            b[r].x=k;b[r].y=j;
                        }
                        while(abs(k-b[l].x)>(tr[i].r-tr[i].l+1)&&l<=r) l++;
                        if(l>r)
                        {
                            f[k][j][i]=999999999;
                        }
                        else
                        {
                            int temp=tr[i].r-tr[i].l+1;
                            f[k][j][i]=b[l].c+(temp-abs(k-b[l].x));
                        }
                    }
                    else
                    {
                        l=1;r=0;
                    }
                }
            }
        }
        if(tr[i].d==2)
        {
            for(int j=1;j<=m;j++)
            {
                int l=1,r=0;
                for(int k=1;k<=n;k++)
                {
                    if(s[k][j]=='.')
                    {
                        if(f[k][j][i-1]!=999999999)
                        {
                            while(b[r].c-abs(k-b[r].x)>f[k][j][i-1]&&l<=r) r--;
                            r++;
                            b[r].c=f[k][j][i-1];
                            b[r].x=k;b[r].y=j;
                        }
                        while(abs(k-b[l].x)>(tr[i].r-tr[i].l+1)&&l<=r) l++;
                        if(l>r)
                        {
                            f[k][j][i]=999999999;
                        }
                        else
                        {
                            int temp=tr[i].r-tr[i].l+1;
                            f[k][j][i]=b[l].c+(temp-abs(k-b[l].x));
                        }
                    }
                    else
                    {
                        l=1;r=0;
                    }
                }
            }
        }
        if(tr[i].d==3)
        {
            for(int k=1;k<=n;k++)
            {
                int l=1,r=0;
                for(int j=m;j>=1;j--)
                {
                    if(s[k][j]=='.')
                    {
                        if(f[k][j][i-1]!=999999999)
                        {
                            while(b[r].c-abs(j-b[r].y)>f[k][j][i-1]&&l<=r) r--;
                            r++;
                            b[r].c=f[k][j][i-1];
                            b[r].x=k;b[r].y=j;
                        }
                        while(abs(j-b[l].y)>(tr[i].r-tr[i].l+1)&&l<=r) l++;
                        if(l>r)
                        {
                            f[k][j][i]=999999999;
                        }
                        else
                        {
                            int temp=tr[i].r-tr[i].l+1;
                            f[k][j][i]=b[l].c+(temp-abs(j-b[l].y));
                        }
                    }
                    else
                    {
                        l=1;r=0;
                    }
                }
            }
        }
        if(tr[i].d==4)
        {
            for(int k=1;k<=n;k++)
            {
                int l=1,r=0;
                for(int j=1;j<=m;j++)
                {
                    if(s[k][j]=='.')
                    {
                        if(f[k][j][i-1]!=999999999)
                        {
                            while(b[r].c-abs(j-b[r].y)>f[k][j][i-1]&&l<=r) r--;
                            r++;
                            b[r].c=f[k][j][i-1];
                            b[r].x=k;b[r].y=j;
                        }
                        while(abs(j-b[l].y)>(tr[i].r-tr[i].l+1)&&l<=r) l++;
                        if(l>r)
                        {
                            f[k][j][i]=999999999;
                        }
                        else
                        {
                            int temp=tr[i].r-tr[i].l+1;
                            f[k][j][i]=b[l].c+(temp-abs(j-b[l].y));
                        }
                    }
                    else
                    {
                        l=1;r=0;
                    }
                }
            }
        }
    }
    int min=999999999;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            min=mymin(min,f[i][j][kk]);
        }
    }
    printf("%d\n",t-min);
    return 0;
}