wikioi-1748 瑰丽华尔兹 -单调队列优化DP

根据题意,很明显可以推出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;
}

wikioi-1748 瑰丽华尔兹 -单调队列优化DP

时间: 2024-10-09 14:34:01

wikioi-1748 瑰丽华尔兹 -单调队列优化DP的相关文章

bzoj1499[NOI2005]瑰丽华尔兹 单调队列优化dp

1499: [NOI2005]瑰丽华尔兹 Time Limit: 3 Sec  Memory Limit: 64 MBSubmit: 1802  Solved: 1097[Submit][Status][Discuss] Description 你跳过华尔兹吗?当音乐响起,当你随着旋律滑动舞步,是不是有一种漫步仙境的惬意?众所周知,跳华尔兹时,最重要的是有好的音乐.但是很少有几个人知道,世界上最伟大的钢琴家一生都漂泊在大海上,他的名字叫丹尼•布德曼•T.D.•柠檬•1900,朋友们都叫他1900

HDU 4122 Alice&#39;s mooncake shop 单调队列优化dp

Alice's mooncake shop Time Limit: 20 Sec Memory Limit: 256 MB 题目连接 http://acm.hdu.edu.cn/showproblem.php?pid=4122 Description The Mid-Autumn Festival, also known as the Moon Festival or Zhongqiu Festival is a popular harvest festival celebrated by Ch

Tyvj1305最大子序和(单调队列优化dp)

描述 输入一个长度为n的整数序列,从中找出一段不超过M的连续子序列,使得整个序列的和最大. 例如 1,-3,5,1,-2,3 当m=4时,S=5+1-2+3=7当m=2或m=3时,S=5+1=6 输入格式 第一行两个数n,m第二行有n个数,要求在n个数找到最大子序和 输出格式 一个数,数出他们的最大子序和 测试样例1 输入 6 4 1 -3 5 1 -2 3 输出 7 备注 数据范围:100%满足n,m<=300000 是不超过m,不是选m个!!!!! /* 单调队列优化dp 单调队列维护的是前

bzoj1855: [Scoi2010]股票交易--单调队列优化DP

单调队列优化DP的模板题 不难列出DP方程: 对于买入的情况 由于dp[i][j]=max{dp[i-w-1][k]+k*Ap[i]-j*Ap[i]} AP[i]*j是固定的,在队列中维护dp[i-w-1][k]+k*Ap[i]的单调性即可 1 #include<stdio.h> 2 #include<string.h> 3 #include<algorithm> 4 using namespace std; 5 const int maxn = 2010; 6 int

1855: [Scoi2010]股票交易[单调队列优化DP]

1855: [Scoi2010]股票交易 Time Limit: 5 Sec  Memory Limit: 64 MBSubmit: 1083  Solved: 519[Submit][Status][Discuss] Description 最近lxhgww又迷上了投资股票,通过一段时间的观察和学习,他总结出了股票行情的一些规律. 通过一段时间的观察,lxhgww预测到了未来T天内某只股票的走势,第i天的股票买入价为每股APi,第i天的股票卖出价为每股BPi(数据保证对于每个i,都有APi>=

BZOJ 1855 股票交易(单调队列优化DP)

题目链接:http://61.187.179.132/JudgeOnline/problem.php?id=1855 题意:最近lxhgww又迷上了投资股票, 通过一段时间的观察和学习,他总结出了股票行情的一些规律. 通过一段时间的观察,lxhgww预测到了未来T天内某只股票的走势,第i天的股票买入价为每股APi,第i天的股票卖出价为每股BPi(数据保证对于每 个i,都有APi>=BPi),但是每天不能无限制地交易,于是股票交易所规定第i天的一次买入至多只能购买ASi股,一次卖出至多只能卖出BS

【单调队列优化dp】uestc 594 我要长高

http://acm.uestc.edu.cn/#/problem/show/594 [AC] 1 #include<bits/stdc++.h> 2 using namespace std; 3 typedef long long ll; 4 const int maxn=5e4+2; 5 const int inf=0x3f3f3f3f; 6 int n,c; 7 int cur; 8 int dp[2][maxn]; 9 int q[maxn]; 10 int main() 11 { 1

洛谷P1725 琪露诺 单调队列优化 DP

洛谷P1725 琪露诺 单调队列优化 DP 题意:1--n 每个点都有一个权值,从当前点i可以到达i+l--i+r 之间的点, 动态规划 方程 为 f[ i ] = max(f[ i ],f[ k ] ) +a[ i ] i-r<=k<=i-l 然而这样复杂度 就为 n^2 因为相当于 dp 是在求 一段区间的最大值,而这个最大值就可以用O(n) 来维护 注意 这个O(n) 是均摊O(n) 即将所有固定区间长度的 最大值求出来 是 O(n)的这样就把复杂度降到 O(n) 级别了 1 #incl

Parade(单调队列优化dp)

题目连接:http://acm.hdu.edu.cn/showproblem.php?pid=2490 Parade Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 902    Accepted Submission(s): 396 Problem Description Panagola, The Lord of city F lik