单调队列1006 POJ 1821 Fence

最新推荐文章于 2022-05-24 15:55:30 发布

humeay

最新推荐文章于 2022-05-24 15:55:30 发布

阅读量219

点赞数

CC 4.0 BY-SA版权

分类专栏：单调队列&单调栈

本文链接：https://blog.youkuaiyun.com/qq_27925701/article/details/51924898

单调队列&单调栈专栏收录该内容

11 篇文章

订阅专栏

本文介绍了一个经典的动态规划问题——粉刷匠问题，并详细解释了解决该问题的算法思路。通过使用单调队列优化状态转移过程，实现了高效求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意:
有一个长度为n的墙壁,有k个粉刷匠来刷墙
每个粉刷匠都有三种属性
1.最大刷墙的距离(必须是连续的区间
2.刷每块墙的价格
3.初始位置(刷墙的区间必须包含初始位置
求这几个粉刷匠刷长度为n的墙最多赚多少钱
思路:
我们考虑
dp[i][j]为前i个粉刷匠刷前j面墙最多的赚的钱
我们考虑对于每个粉刷匠刷墙
把墙分成两种
1.能刷到的
2.刷不到的
对于刷不到的我们自然就取dp[i-1][j]和dp[i][j-1]了
对于能刷到的
如果当前粉刷匠要刷的话就是
dp[i][k]+(j-k)*price[i]由于当前j是固定的
所以我们只需要求最大的dp[i][k]-k*price[i]
还有一点是我们对于每个j的k的范围是要变的
所以我们相当于维护一个固定大小的窗口里的最大值
所以就要用到单调队列了

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
#include<string>
#include<vector>
#include<map>
#include<set>
using namespace std;
#define lowbit(x) (x&(-x))
typedef long long LL;
const int maxn = 16005;
const int inf=(1<<28)-1;
struct node
{
    int MaxDis,Price,InitPos;
    int Left,Right;
}A[105];
bool cmp(node u,node v)
{
    return u.InitPos<v.InitPos;
}
deque<pair<int,int> >Que;
int dp[105][maxn];
int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        for(int i=1;i<=k;++i)
        {
            scanf("%d%d%d",&A[i].MaxDis,&A[i].Price,&A[i].InitPos);
            A[i].Left=max(0,A[i].InitPos-A[i].MaxDis);//因为我们取得是当前点之后墙
            A[i].Right=min(n,A[i].InitPos+A[i].MaxDis-1); 
        }
        sort(A+1,A+k+1,cmp);
        //因为我们dp[i][k]是需要之前的max(dp[1~i][0~k-1])
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=k;++i)
        {
            Que.clear();
            for(int j=0;j<=n;++j)//同样是因为我们取得是当前点以及之前为不覆盖范围,所以需要0
            {
                if(j) dp[i][j]=dp[i][j-1];
                dp[i][j]=max(dp[i][j],dp[i-1][j]);
                if(A[i].Left<=j&&j<A[i].InitPos)
                {
                    int SubNum=dp[i-1][j]-j*A[i].Price;
                    while(!Que.empty()&&SubNum>=Que.back().first)
                    {
                        Que.pop_back();
                    }
                    Que.push_back(make_pair(SubNum,j));
                }
                if(A[i].InitPos<=j&&j<=A[i].Right)
                {
                    int Tmp=j*A[i].Price;
                    while(!Que.empty()&&j-Que.front().second>A[i].MaxDis)
                    {
                        Que.pop_front();
                    }
                    dp[i][j]=max(dp[i][j],Que.front().first+Tmp);
                }
            }
        }
        printf("%d\n",dp[k][n]);
    }
    return 0;
}